From 732bf2e7fde23ce250d3bcd365b66f0641223779 Mon Sep 17 00:00:00 2001 From: gr0vity Date: Sat, 9 Jul 2022 00:01:53 +0200 Subject: [PATCH 01/34] add started_election websocket topic and core_test --- nano/core_test/websocket.cpp | 40 +++++++++++++++++++++++++++++++ nano/node/active_transactions.cpp | 1 + nano/node/node.cpp | 8 +++++++ nano/node/node_observers.cpp | 1 + nano/node/node_observers.hpp | 1 + nano/node/websocket.cpp | 20 ++++++++++++++++ nano/node/websocket.hpp | 3 +++ 7 files changed, 74 insertions(+) diff --git a/nano/core_test/websocket.cpp b/nano/core_test/websocket.cpp index 4f3d192871..e2e9d08f54 100644 --- a/nano/core_test/websocket.cpp +++ b/nano/core_test/websocket.cpp @@ -116,6 +116,46 @@ TEST (websocket, confirmation) ASSERT_TIMELY (5s, future.wait_for (0s) == std::future_status::ready); } +// Tests getting notification of a started election +TEST (websocket, started_election) +{ + nano::system system; + nano::node_config config (nano::get_available_port (), system.logging); + config.websocket_config.enabled = true; + config.websocket_config.port = nano::get_available_port (); + auto node1 (system.add_node (config)); + + std::atomic ack_ready{ false }; + auto task = ([&ack_ready, config, &node1] () { + fake_websocket_client client (node1->websocket_server->listening_port ()); + client.send_message (R"json({"action": "subscribe", "topic": "started_election", "ack": "true"})json"); + client.await_ack (); + ack_ready = true; + EXPECT_EQ (1, node1->websocket_server->subscriber_count (nano::websocket::topic::started_election)); + return client.get_response (); + }); + auto future = std::async (std::launch::async, task); + + ASSERT_TIMELY (5s, ack_ready); + + // Create election, causing a websocket message to be emitted + nano::keypair key1; + 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.inbound (publish1, channel1); + ASSERT_TIMELY (1s, node1->active.election (send1->qualified_root ())); + ASSERT_TIMELY (5s, future.wait_for (0s) == std::future_status::ready); + + auto response = future.get (); + ASSERT_TRUE (response); + boost::property_tree::ptree event; + std::stringstream stream; + stream << response.get (); + boost::property_tree::read_json (stream, event); + ASSERT_EQ (event.get ("topic"), "started_election"); +} + // Tests getting notification of an erased election TEST (websocket, stopped_election) { diff --git a/nano/node/active_transactions.cpp b/nano/node/active_transactions.cpp index 3b389d6d40..9df65e523f 100644 --- a/nano/node/active_transactions.cpp +++ b/nano/node/active_transactions.cpp @@ -831,6 +831,7 @@ nano::election_insertion_result nano::active_transactions::insert_impl (nano::un auto const cache = find_inactive_votes_cache_impl (hash); lock_a.unlock (); result.election->insert_inactive_votes_cache (cache); + node.observers.active_started.notify (hash); node.stats.inc (nano::stat::type::election, nano::stat::detail::election_start); vacancy_update (); } diff --git a/nano/node/node.cpp b/nano/node/node.cpp index 7a11e2fd1d..8dbb942c9c 100644 --- a/nano/node/node.cpp +++ b/nano/node/node.cpp @@ -281,6 +281,14 @@ nano::node::node (boost::asio::io_context & io_ctx_a, boost::filesystem::path co } }); + observers.active_started.add ([this] (nano::block_hash const& hash_a) { + if (this->websocket_server->any_subscriber (nano::websocket::topic::started_election)) + { + nano::websocket::message_builder builder; + this->websocket_server->broadcast (builder.started_election (hash_a)); + } + }); + observers.active_stopped.add ([this] (nano::block_hash const & hash_a) { if (this->websocket_server->any_subscriber (nano::websocket::topic::stopped_election)) { diff --git a/nano/node/node_observers.cpp b/nano/node/node_observers.cpp index 1544be3afe..5864dbce8d 100644 --- a/nano/node/node_observers.cpp +++ b/nano/node/node_observers.cpp @@ -6,6 +6,7 @@ std::unique_ptr nano::collect_container_info (na composite->add_component (collect_container_info (node_observers.blocks, "blocks")); composite->add_component (collect_container_info (node_observers.wallet, "wallet")); composite->add_component (collect_container_info (node_observers.vote, "vote")); + composite->add_component (collect_container_info (node_observers.active_started, "active_started")); composite->add_component (collect_container_info (node_observers.active_stopped, "active_stopped")); composite->add_component (collect_container_info (node_observers.account_balance, "account_balance")); composite->add_component (collect_container_info (node_observers.endpoint, "endpoint")); diff --git a/nano/node/node_observers.hpp b/nano/node/node_observers.hpp index cea357eb10..c3e95c8a92 100644 --- a/nano/node/node_observers.hpp +++ b/nano/node/node_observers.hpp @@ -15,6 +15,7 @@ class node_observers final blocks_t blocks; nano::observer_set wallet; nano::observer_set, std::shared_ptr, nano::vote_code> vote; + nano::observer_set active_started; nano::observer_set active_stopped; nano::observer_set account_balance; nano::observer_set> endpoint; diff --git a/nano/node/websocket.cpp b/nano/node/websocket.cpp index 67b057ac24..a569adb470 100644 --- a/nano/node/websocket.cpp +++ b/nano/node/websocket.cpp @@ -375,6 +375,10 @@ nano::websocket::topic to_topic (std::string const & topic_a) { topic = nano::websocket::topic::confirmation; } + else if (topic_a == "started_election") + { + topic = nano::websocket::topic::started_election; + } else if (topic_a == "stopped_election") { topic = nano::websocket::topic::stopped_election; @@ -414,6 +418,10 @@ std::string from_topic (nano::websocket::topic topic_a) { topic = "confirmation"; } + else if (topic_a == nano::websocket::topic::started_election) + { + topic = "started_election"; + } else if (topic_a == nano::websocket::topic::stopped_election) { topic = "stopped_election"; @@ -689,6 +697,18 @@ void nano::websocket::listener::decrease_subscriber_count (nano::websocket::topi count -= 1; } +nano::websocket::message nano::websocket::message_builder::started_election(nano::block_hash const& hash_a) +{ + nano::websocket::message message_l(nano::websocket::topic::started_election); + set_common_fields(message_l); + + boost::property_tree::ptree message_node_l; + message_node_l.add("hash", hash_a.to_string()); + message_l.contents.add_child("message", message_node_l); + + return message_l; +} + nano::websocket::message nano::websocket::message_builder::stopped_election (nano::block_hash const & hash_a) { nano::websocket::message message_l (nano::websocket::topic::stopped_election); diff --git a/nano/node/websocket.hpp b/nano/node/websocket.hpp index 264a9f9404..dd72b67dd8 100644 --- a/nano/node/websocket.hpp +++ b/nano/node/websocket.hpp @@ -41,6 +41,8 @@ namespace websocket ack, /** A confirmation message */ confirmation, + /** Started election message*/ + started_election, /** Stopped election message (dropped elections due to bounding or block lost the elections) */ stopped_election, /** A vote message **/ @@ -81,6 +83,7 @@ namespace websocket { public: message block_confirmed (std::shared_ptr const & block_a, nano::account const & account_a, nano::amount const & amount_a, std::string subtype, bool include_block, nano::election_status const & election_status_a, std::vector const & election_votes_a, nano::websocket::confirmation_options const & options_a); + message started_election (nano::block_hash const& hash_a); message stopped_election (nano::block_hash const & hash_a); message vote_received (std::shared_ptr const & vote_a, nano::vote_code code_a); message work_generation (nano::work_version const version_a, nano::block_hash const & root_a, uint64_t const work_a, uint64_t const difficulty_a, uint64_t const publish_threshold_a, std::chrono::milliseconds const & duration_a, std::string const & peer_a, std::vector const & bad_peers_a, bool const completed_a = true, bool const cancelled_a = false); From 02988c423878b9426fa8532df1b6f516f2cbbbd5 Mon Sep 17 00:00:00 2001 From: gr0vity Date: Sat, 9 Jul 2022 12:29:21 +0200 Subject: [PATCH 02/34] clang format --- nano/core_test/websocket.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/nano/core_test/websocket.cpp b/nano/core_test/websocket.cpp index e2e9d08f54..a266ef4f0a 100644 --- a/nano/core_test/websocket.cpp +++ b/nano/core_test/websocket.cpp @@ -143,8 +143,8 @@ TEST (websocket, started_election) 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.inbound (publish1, channel1); - ASSERT_TIMELY (1s, node1->active.election (send1->qualified_root ())); + node1->network.inbound (publish1, channel1); + ASSERT_TIMELY (1s, node1->active.election (send1->qualified_root ())); ASSERT_TIMELY (5s, future.wait_for (0s) == std::future_status::ready); auto response = future.get (); From 761b64977c09ec6d3e69133a4e6ecb833ec5825c Mon Sep 17 00:00:00 2001 From: Russel Waters Date: Tue, 1 Mar 2022 23:37:25 -0800 Subject: [PATCH 03/34] initial centos cleanup rpm build image, and signing container rpm build updates --- .github/workflows/live_artifacts.yml | 28 ++++ ci/actions/linux/install_deps.sh | 1 + ci/build-centos.sh | 13 +- docker/ci/Dockerfile-centos | 8 + docker/sign/Dockerfile-signer | 24 +++ docker/sign/README.MD | 21 +++ docker/sign/entry.sh | 57 +++++++ util/build_prep/centos/prep.sh.in | 4 +- util/changelog.py | 225 ++++++++++++++++----------- util/makesrc | 36 ++--- 10 files changed, 301 insertions(+), 116 deletions(-) create mode 100644 docker/ci/Dockerfile-centos create mode 100644 docker/sign/Dockerfile-signer create mode 100644 docker/sign/README.MD create mode 100755 docker/sign/entry.sh diff --git a/.github/workflows/live_artifacts.yml b/.github/workflows/live_artifacts.yml index fc5c959902..cd5d9abdce 100644 --- a/.github/workflows/live_artifacts.yml +++ b/.github/workflows/live_artifacts.yml @@ -66,6 +66,34 @@ jobs: AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }} AWS_DEFAULT_REGION: us-east-2 + linux_rpm_job: + runs-on: ubuntu-20.04 + timeout-minutes: 90 + steps: + - name: tag + run: | + echo "TAG=${{ github.event.inputs.ref }}" >> $GITHUB_ENV + - uses: actions/checkout@5a4ac9002d0be2fb38bd78e4b4dbde5606d7042f + with: + submodules: "recursive" + ref: ${{ github.event.inputs.ref }} + repository: ${{ github.event.inputs.repo }} + - name: centos base + run: ci/build-docker-image.sh docker/ci/Dockerfile-centos nanocurrency/nano-env:centos + - name: Build Artifact + run: | + docker run -e LIVE=1 -v ${GITHUB_WORKSPACE}:/workspace \ + -v artifacts:/root/rpmbuild/RPMS -v source:/root/rpmbuild/SOURCES \ + nanocurrency/nano-env:centos /bin/bash -c "ci/build-centos.sh" + env: + PAT: ${{ secrets.GITHUB_TOKEN }} + - name: Deploy Artifact + run: ci/actions/deploy.sh + 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 + linux_docker_job: runs-on: ubuntu-20.04 timeout-minutes: 90 diff --git a/ci/actions/linux/install_deps.sh b/ci/actions/linux/install_deps.sh index fb421c441a..52a82a51cb 100755 --- a/ci/actions/linux/install_deps.sh +++ b/ci/actions/linux/install_deps.sh @@ -8,4 +8,5 @@ if [[ "${COMPILER:-}" != "" ]]; then 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 + ci/build-docker-image.sh docker/ci/Dockerfile-centos nanocurrency/nano-env:centos fi diff --git a/ci/build-centos.sh b/ci/build-centos.sh index 19b6bee18a..6f9c7cf49e 100755 --- a/ci/build-centos.sh +++ b/ci/build-centos.sh @@ -1,17 +1,20 @@ #!/usr/bin/env bash -TAGS=$(git describe --abbrev=0 --tags) -VERSIONS=${TAGS//V/} +TAG=$(echo $TAG) +VERSIONS=${TAG//V/} RELEASE=$(echo $CI_JOB_ID) run_source() { - ./util/makesrc $TAGS + ./util/makesrc $TAG $(echo $PAT) } run_build() { mkdir -p ~/rpmbuild/SOURCES/ mv -f ~/nano-${VERSIONS}.tar.gz ~/rpmbuild/SOURCES/. - scl enable devtoolset-7 'rpmbuild -ba nanocurrency.spec' - scl enable devtoolset-7 'rpmbuild -ba nanocurrency-beta.spec' + if [ "${LIVE:-}" == "1" ]; then + scl enable devtoolset-7 'rpmbuild -ba nanocurrency.spec' + else + scl enable devtoolset-7 'rpmbuild -ba nanocurrency-beta.spec' + fi } run_update() { diff --git a/docker/ci/Dockerfile-centos b/docker/ci/Dockerfile-centos new file mode 100644 index 0000000000..f295845e23 --- /dev/null +++ b/docker/ci/Dockerfile-centos @@ -0,0 +1,8 @@ +FROM centos:7 + +WORKDIR /workspace + +ADD util /build +RUN bash /build/build_prep/update-common +RUN bash /build/build_prep/centos/prep.sh +RUN rm -rf /build diff --git a/docker/sign/Dockerfile-signer b/docker/sign/Dockerfile-signer new file mode 100644 index 0000000000..41a182012e --- /dev/null +++ b/docker/sign/Dockerfile-signer @@ -0,0 +1,24 @@ +FROM python:3.9-buster + + +ENV DEBIAN_FRONTEND="noninteractive" +ENV TZ="America/Los_Angeles" +ENV GPG_TTY=/dev/console + +ARG GPG_PRIVATE_KEY +ARG GPG_SIGNER + +## Install required for rpm signing +RUN apt-get update -yqq && \ + apt-get install -y librpmsign8 gnupg2 wget rpm + +## Additional for mkrepo support +RUN python3 -m pip install mkrepo boto3 + +#WORKDIR /signing +#RUN python3 -m venv && .venv/bin/pip install mkrepo + +## Control Entrypoint +ADD docker/sign/entry.sh /usr/local/bin/entry.sh + +ENTRYPOINT [ "entry.sh" ] diff --git a/docker/sign/README.MD b/docker/sign/README.MD new file mode 100644 index 0000000000..769cc60ff2 --- /dev/null +++ b/docker/sign/README.MD @@ -0,0 +1,21 @@ +## Usage + +### Build + +`docker build . -f docker/sign/Dockerfile-signer -t ` + +### Required Variables +* GPG_PRIVATE_KEY -> base64 encoded GPG private signing key +* GPG_SIGNER -> key id to sign with, must match GPG_PRIVATE_KEY +* S3_ACCESS_KEY_ID -> S3 Key with access to rpm/repo +* S3_SECRET_ACCES_KEY -> S3 Secret for S3_ACCESS_KEY_ID + +### Sign RPM artifacts +`docker run --rm -it -e GPG_PRIVATE_KEY -e GPG_SIGNER -v :/tmp rpm-sign /tmp` + +### Upload RPM artifacts +Upload artifacts to appropriate location + +### Update Repo Metadata Files + +`docker run --rm -it -e GPG_PRIVATE_KEY -e GPG_SIGNER -e S3_ACCESS_KEY_ID -e S3_SECRET_ACCESS_KEY repo-update ` \ No newline at end of file diff --git a/docker/sign/entry.sh b/docker/sign/entry.sh new file mode 100755 index 0000000000..ed5c5a03e0 --- /dev/null +++ b/docker/sign/entry.sh @@ -0,0 +1,57 @@ +#!/bin/bash + +if [ -z "${GPG_PRIVATE_KEY}" ]; then + echo "GPG_PRIVATE_KEY not set" + exit 1 +fi + +if [ -z "${GPG_SIGNER}" ]; then + echo "GPG_SIGNER not set" + exit 1 +fi + +echo "${GPG_PRIVATE_KEY}" | base64 -d | gpg2 --import --no-tty --yes + +cat < /root/.rpmmacros +%_signature gpg +%_gpg_name ${GPG_SIGNER} +%_gpg_path /root/.gnupg +%_gpgbin /usr/bin/gpg2 +EOF + + +if [ "${1}" == "rpm-sign" ]; then + if [ -z "${2}" ]; then + echo "Usage: ${0} rpm-sign " + exit 1 + fi + for a in `ls ${2}/*.rpm`; do + rpm --addsign "${a}" + done + exit 0 +elif [ "${1}" == "repo-update" ]; then + if [ -z "${S3_ACCESS_KEY_ID}" ]; then + echo "S3_ACCESS_KEY_ID not set" + exit 1 + fi + if [ -z "${S3_SECRET_ACCESS_KEY}" ]; then + echo "S3_SECRET_ACCESS_KEY not set" + exit 1 + fi + if [ -z "${S3_REGION}" ]; then + echo "Defaulting S3_REGION to us-east-2" + export S3_REGION="us-east-2" + fi + if [ -z "${2}" ]; then + echo "Usage: ${0} repo-update " + exit 1 + fi + mkrepo --s3-access-key-id ${S3_ACCESS_KEY_ID} \ + --s3-secret-access-key ${S3_SECRET_ACCESS_KEY} \ + --s3-public-read --s3-region ${S3_REGION} \ + ${2} + +else + echo "Usage: ${0} " + exit 1 +fi \ No newline at end of file diff --git a/util/build_prep/centos/prep.sh.in b/util/build_prep/centos/prep.sh.in index a321cfd38b..75034f70d2 100644 --- a/util/build_prep/centos/prep.sh.in +++ b/util/build_prep/centos/prep.sh.in @@ -14,6 +14,8 @@ yes | yum install -y rpm-build || exit 1 yes | yum install -y glibc-devel glibc-headers make which libstdc++-static || exit 1 yes | yum install -y centos-release-scl || exit 1 yes | yum install -y devtoolset-7-gcc-c++ || exit 1 +yes | yum install -y rh-python38 || exit 1 + 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 @@ -25,7 +27,7 @@ rm -f ./cmake_install.sh ( eval "$(scl enable devtoolset-7 "bash -c 'set | grep ^PATH='")" if ! have boost; then - bootstrap_boost -m -s + bootstrap_boost -m -s -j`nproc` fi if ! have boost; then diff --git a/util/changelog.py b/util/changelog.py index dd61cc0d5d..a4081d89b5 100755 --- a/util/changelog.py +++ b/util/changelog.py @@ -1,18 +1,35 @@ import argparse import copy import sys +import re +from typing import Tuple """ Changelog generation script, requires PAT with public_repo access, see https://github.com/settings/tokens -Caveats V20 and prior release tags are tips on their respective release branches -If you try to use a start tag with one of these a full changelog will be generated -since the commit wont appear in your iterations +usage: changelog [-h] [-e END] [-m {full,incremental}] -p PAT [-r REPO] [-s START] [-t TAG] + +Generate Changelogs between tags or commits + +optional arguments: + -h, --help show this help message and exit + -e END, --end END Ending reference for Changelog(newest) + -m {full,incremental}, --mode {full,incremental} + Mode to run changelog for [full, incremental] + -p PAT, --pat PAT Personal Access Token + -r REPO, --repo REPO to generate logs for + -s START, --start START + Starting reference for Changelog(oldest) + -t TAG, --tag TAG Tag to use for changelog generation """ + +full = re.compile(r"^(V(\d)+.(\d)+.?(\d)?)$") +incremental = re.compile(r"^(V(\d)+.(\d)+.?(\d)?(RC(\d)+)?(DB(\d)+)?)$") + try: - from github import Github,UnknownObjectException + from github import Github, UnknownObjectException from mdutils import MdUtils except BaseException: sys.exit("Error: run 'pip install PyGithub mdutils'") @@ -80,114 +97,132 @@ class cliArgs(): - def __init__(self): + def __init__(self) -> dict: + + changelog_choices = ["full", "incremental"] + parse = argparse.ArgumentParser( prog="changelog", description="Generate Changelogs between tags or commits" ) + parse.add_argument( - '-r', '--repo', - help=" to generate logs for", + '-e', '--end', + help="Ending reference for Changelog(newest)", type=str, action="store", - default='nanocurrency/nano-node', ) parse.add_argument( - '-s', '--start', - help="Starting reference for Changelog", + "-m", "--mode", + help="Mode to run changelog for [full, incremental]", type=str, action="store", - required=True, + default="incremental", + choices=changelog_choices ) parse.add_argument( - '-e', '--end', - help="Ending reference for Changelog", + '-p', '--pat', + help="Personal Access Token", type=str, action="store", required=True, ) parse.add_argument( - '--pat', - help="Personal Access Token", + '-r', '--repo', + help=" to generate logs for", + type=str, action="store", + default='nanocurrency/nano-node', + ) + parse.add_argument( + '-s', '--start', + help="Starting reference for Changelog(oldest)", type=str, action="store", - required=True, + ) + parse.add_argument( + '-t', '--tag', + help="Tag to use for changelog generation", + type=str, action="store" ) options = parse.parse_args() - self.repo = options.repo.rstrip("/") - self.start = options.start self.end = options.end + self.mode = options.mode self.pat = options.pat - def __repr__(self): - return "" \ - .format(self.repo, self.start, self.end, self.pat) - def __str__(self): - return "Generating a changelog for {0} starting with {1} " \ - "and ending with {2}".format(self.repo, self.start, self.end) + self.repo = options.repo.rstrip("/") + self.start = options.start + self.tag = options.tag + + class generateTree: def __init__(self, args): github = Github(args.pat) self.name = args.repo - self.repo = github.get_repo(args.repo) - self.start = args.start - self.end = args.end - try: - self.startCommit = self.repo.get_commit(args.start) - except BaseException: - exit("Error finding commit for " + args.start) - try: - self.endCommit = self.repo.get_commit(args.end) - except BaseException: - exit("Error finding commit for " + args.end) - commits = self.repo.get_commits(sha=self.endCommit.sha) + self.repo = github.get_repo(self.name) + if args.tag: + self.tag = args.tag + self.end = self.repo.get_commit(args.tag).sha + elif args.end: + self.end = self.repo.get_commit(args.end).sha + else: + print("need end or tag") + exit(1) + if args.start: + self.start = self.repo.get_commit(args.start).sha + else: + self.start = self.get_common(args.mode) self.commits = {} - self.other_commits = [] # for commits that do not have an associated pull + self.other_commits = [] + commits = self.repo.get_commits(sha=self.end) for commit in commits: - if commit.sha == self.startCommit.sha: + if commit.sha == self.start: break - else: - message = commit.commit.message.partition('\n')[0] - try: - pr_number = int( - message[message.rfind('#')+1:message.rfind(')')]) + m = commit.commit.message.partition('\n')[0] + try: + pr_number = int(m[m.rfind('#')+1:m.rfind(')')]) + pull = self.repo.get_pull(pr_number) + except (ValueError, UnknownObjectException): + p = commit.get_pulls() + if p.totalCount > 0: + pr_number = p[0].number pull = self.repo.get_pull(pr_number) - except (ValueError, UnknownObjectException): - pulls = commit.get_pulls() - if pulls.totalCount > 0: - # no commits with more than 1 PR associated to it were found in V23 release - # but targeting first entry only if that ends up being the case - pr_number = pulls[0].number - pull = self.repo.get_pull(pr_number) - else: - print("Commit has no associated PR {}: \"{}\"".format( - commit.sha, message)) - self.other_commits.append((commit.sha, message)) - continue - - labels = [] - for label in pull.labels: - labels.append(label.name) - self.commits[pull.number] = { - "Title": pull.title, - "Url": pull.html_url, - "labels": labels - } - def __repr__(self): - return " Tuple[str, bool]: for section, values in SECTIONS.items(): for label in labels: if label in values: @@ -233,7 +272,8 @@ def handle_labels(self, labels): else: return section, False return 'Other', False - def pull_to_section(self, commits): + + def pull_to_section(self, commits) -> dict: sect = copy.deepcopy(SECTIONS) result = {} for a in sect: @@ -248,7 +288,8 @@ def pull_to_section(self, commits): if len(sect[a]) > 0: result[a] = sect[a] return result -if __name__ == "__main__": - args = cliArgs() - repo = generateTree(args) - generateMarkdown(repo) + + +arg = cliArgs() +trees = generateTree(arg) +generateMarkdown(trees) diff --git a/util/makesrc b/util/makesrc index 50bb6fa999..f42a06ba81 100755 --- a/util/makesrc +++ b/util/makesrc @@ -1,23 +1,24 @@ #!/bin/bash -# makesrc -# requires ruby gem github_changelog_generator -# API_KEY generated here https://github.com/settings/tokens/new?description=GitHub%20Changelog%20Generator%20token +# makesrc +# personal access token allows around rate limit -if [ -e $1 ]; then - echo "makesrc " >&2 +if [ -e $2 ]; then + echo "makesrc " >&2 echo " tag valid for nanocurrency/nano-node" >&2 + echo " pat personal access token" >&2 exit 1 fi TAG="$1" +PAT="$2" VERSION=$(echo $TAG | sed 's/V//') TAG_DATE="" VERSION_MAJOR=$(echo $VERSION | cut -d "." -f 1) scriptDir="$(dirname "$(readlink -f "${BASH_SOURCE[0]}")")" function make_source() { - git clone --recursive --single-branch --branch releases/v${VERSION_MAJOR} https://github.com/nanocurrency/nano-node nano-$VERSION + git clone --recursive --single-branch --branch ${TAG} https://github.com/nanocurrency/nano-node nano-$VERSION cd nano-$VERSION git pull --tags COUNT=$(git tag -l "${TAG}" | wc -l) @@ -39,19 +40,18 @@ function source_information() { COMMIT=$(git log | head -1 | cut -d " " -f 2) TAG_DATE=$(TZ=UTC date -d"$DATE" +%s) - case "${VERSION}" in - *RC*) - "${scriptDir}/changelog_generator" nanocurrency/nano-node "V${VERSION}" only - ;; - *) - "${scriptDir}/changelog_generator" nanocurrency/nano-node "V${VERSION}" - ;; - esac + ( + eval "$(scl enable rh-python38 'echo -e "source /opt/rh/rh-python38/enable\n"')" + python -m pip install PyGithub mdutils - if [ ! -s CHANGELOG.md ]; then - echo "CHANGELOG not generated" - exit 1 - fi + python ${scriptDir}/changelog.py -p ${PAT} -t ${TAG} -m full + + if [ ! -s CHANGELOG.md ]; then + echo "CHANGELOG not generated" + exit 1 + fi + exit 0 + ) || exit 1 export TAG_DATE } From 9869810521a93672a50735fc4684b3b356e0161b Mon Sep 17 00:00:00 2001 From: Thiago Silva Date: Wed, 4 May 2022 18:17:30 -0300 Subject: [PATCH 04/34] Fixes to let it run in the CI --- .github/workflows/live_artifacts.yml | 15 ++++++++------- ci/actions/deploy.sh | 18 ++++++++++++++++-- util/build_prep/centos/prep.sh.in | 2 +- util/makesrc | 26 +++++++++++++------------- 4 files changed, 38 insertions(+), 23 deletions(-) diff --git a/.github/workflows/live_artifacts.yml b/.github/workflows/live_artifacts.yml index cd5d9abdce..633b216e38 100644 --- a/.github/workflows/live_artifacts.yml +++ b/.github/workflows/live_artifacts.yml @@ -70,7 +70,7 @@ jobs: runs-on: ubuntu-20.04 timeout-minutes: 90 steps: - - name: tag + - name: Checkout the Tag run: | echo "TAG=${{ github.event.inputs.ref }}" >> $GITHUB_ENV - uses: actions/checkout@5a4ac9002d0be2fb38bd78e4b4dbde5606d7042f @@ -78,18 +78,19 @@ jobs: submodules: "recursive" ref: ${{ github.event.inputs.ref }} repository: ${{ github.event.inputs.repo }} - - name: centos base + - name: CentOS Base run: ci/build-docker-image.sh docker/ci/Dockerfile-centos nanocurrency/nano-env:centos - name: Build Artifact run: | - docker run -e LIVE=1 -v ${GITHUB_WORKSPACE}:/workspace \ - -v artifacts:/root/rpmbuild/RPMS -v source:/root/rpmbuild/SOURCES \ + mkdir -p ${GITHUB_WORKSPACE}/artifacts + docker run -e LIVE=1 -e PAT=${{ secrets.GITHUB_TOKEN }} \ + -e TAG=$TAG -v ${GITHUB_WORKSPACE}:/workspace \ + -v ${GITHUB_WORKSPACE}/artifacts:/root/rpmbuild \ nanocurrency/nano-env:centos /bin/bash -c "ci/build-centos.sh" - env: - PAT: ${{ secrets.GITHUB_TOKEN }} - - name: Deploy Artifact + - name: Deploy Artifacts run: ci/actions/deploy.sh env: + LINUX_RPM: 1 AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }} AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }} AWS_DEFAULT_REGION: us-east-2 diff --git a/ci/actions/deploy.sh b/ci/actions/deploy.sh index 88bee52ed0..6895108c9d 100755 --- a/ci/actions/deploy.sh +++ b/ci/actions/deploy.sh @@ -4,6 +4,7 @@ set -o errexit set -o nounset set -o xtrace OS=$(uname) +IS_RPM_DEPLOY="${LINUX_RPM:-0}" if [[ "${BETA:-0}" -eq 1 ]]; then BUILD="beta" @@ -19,7 +20,20 @@ else DIRECTORY="${S3_BUILD_DIRECTORY}/${BUILD}" fi -if [[ "$OS" == 'Linux' ]]; then +if [[ "$OS" == 'Linux' && "$IS_RPM_DEPLOY" -eq "1" ]]; then + RPMS=$(find ${GITHUB_WORKSPACE}/artifacts/RPMS -type f -name '*.rpm') + SRPMS=$(find ${GITHUB_WORKSPACE}/artifacts/SRPMS -type f -name '*.src.rpm') + for rpm in $RPMS; do + sha256sum $rpm > "${GITHUB_WORKSPACE}/${rpm}.sha256" + aws s3 cp "${rpm}" s3://repo.nano.org/$DIRECTORY/binaries/$(basename "${rpm}") --grants read=uri=http://acs.amazonaws.com/groups/global/AllUsers + aws s3 cp "${GITHUB_WORKSPACE}/${rpm}.sha256" s3://repo.nano.org/$DIRECTORY/binaries/$(basename "${rpm}.sha256") --grants read=uri=http://acs.amazonaws.com/groups/global/AllUsers + done + for srpm in $SRPMS; do + sha256sum $srpm > "${GITHUB_WORKSPACE}/${srpm}.sha256" + aws s3 cp "${srpm}" s3://repo.nano.org/$DIRECTORY/source/$(basename "${srpm}") --grants read=uri=http://acs.amazonaws.com/groups/global/AllUsers + aws s3 cp "${GITHUB_WORKSPACE}/${srpm}.sha256" s3://repo.nano.org/$DIRECTORY/source/$(basename "${srpm}.sha256") --grants read=uri=http://acs.amazonaws.com/groups/global/AllUsers + done +elif [[ "$OS" == 'Linux' ]]; then sha256sum $GITHUB_WORKSPACE/build/nano-node-*-Linux.tar.bz2 >$GITHUB_WORKSPACE/nano-node-$TAG-Linux.tar.bz2.sha256 sha256sum $GITHUB_WORKSPACE/build/nano-node-*-Linux.deb >$GITHUB_WORKSPACE/nano-node-$TAG-Linux.deb.sha256 aws s3 cp $GITHUB_WORKSPACE/build/nano-node-*-Linux.tar.bz2 s3://repo.nano.org/$DIRECTORY/binaries/nano-node-$TAG-Linux.tar.bz2 --grants read=uri=http://acs.amazonaws.com/groups/global/AllUsers @@ -30,4 +44,4 @@ else sha256sum $GITHUB_WORKSPACE/build/nano-node-*-Darwin.dmg >$GITHUB_WORKSPACE/build/nano-node-$TAG-Darwin.dmg.sha256 aws s3 cp $GITHUB_WORKSPACE/build/nano-node-*-Darwin.dmg s3://repo.nano.org/$DIRECTORY/binaries/nano-node-$TAG-Darwin.dmg --grants read=uri=http://acs.amazonaws.com/groups/global/AllUsers aws s3 cp $GITHUB_WORKSPACE/build/nano-node-$TAG-Darwin.dmg.sha256 s3://repo.nano.org/$DIRECTORY/binaries/nano-node-$TAG-Darwin.dmg.sha256 --grants read=uri=http://acs.amazonaws.com/groups/global/AllUsers -fi \ No newline at end of file +fi diff --git a/util/build_prep/centos/prep.sh.in b/util/build_prep/centos/prep.sh.in index 75034f70d2..8835fa2cd3 100644 --- a/util/build_prep/centos/prep.sh.in +++ b/util/build_prep/centos/prep.sh.in @@ -7,7 +7,7 @@ yes | yum update -y yes | yum install -y git wget openssl bzip2 # -yes | yum install https://dl.fedoraproject.org/pub/epel/epel-release-latest-7.noarch.rpm # epel 7 +yes | yum install -y https://dl.fedoraproject.org/pub/epel/epel-release-latest-7.noarch.rpm # epel 7 yes | yum install -y jq || exit 1 yes | yum install -y rpm-build || exit 1 diff --git a/util/makesrc b/util/makesrc index f42a06ba81..ca0a32aac3 100755 --- a/util/makesrc +++ b/util/makesrc @@ -20,7 +20,7 @@ scriptDir="$(dirname "$(readlink -f "${BASH_SOURCE[0]}")")" function make_source() { git clone --recursive --single-branch --branch ${TAG} https://github.com/nanocurrency/nano-node nano-$VERSION cd nano-$VERSION - git pull --tags + git fetch --tags COUNT=$(git tag -l "${TAG}" | wc -l) if [ "$COUNT" -eq 0 ]; then echo "tag $TAG not found" @@ -40,18 +40,18 @@ function source_information() { COMMIT=$(git log | head -1 | cut -d " " -f 2) TAG_DATE=$(TZ=UTC date -d"$DATE" +%s) - ( - eval "$(scl enable rh-python38 'echo -e "source /opt/rh/rh-python38/enable\n"')" - python -m pip install PyGithub mdutils - - python ${scriptDir}/changelog.py -p ${PAT} -t ${TAG} -m full - - if [ ! -s CHANGELOG.md ]; then - echo "CHANGELOG not generated" - exit 1 - fi - exit 0 - ) || exit 1 +# ( +# eval "$(scl enable rh-python38 'echo -e "source /opt/rh/rh-python38/enable\n"')" +# python -m pip install PyGithub mdutils +# +# python ${scriptDir}/changelog.py -p ${PAT} -t ${TAG} -m full +# +# if [ ! -s CHANGELOG.md ]; then +# echo "CHANGELOG not generated" +# exit 1 +# fi +# exit 0 +# ) || exit 1 export TAG_DATE } From 753142f486d390b5b03ab657831dd8dce3f808a7 Mon Sep 17 00:00:00 2001 From: Thiago Silva Date: Mon, 16 May 2022 13:31:00 -0300 Subject: [PATCH 05/34] Changes the repo to be passed as argument --- .github/workflows/live_artifacts.yml | 6 ++++-- ci/build-centos.sh | 3 ++- util/makesrc | 8 +++++--- 3 files changed, 11 insertions(+), 6 deletions(-) diff --git a/.github/workflows/live_artifacts.yml b/.github/workflows/live_artifacts.yml index 633b216e38..de1fc72f85 100644 --- a/.github/workflows/live_artifacts.yml +++ b/.github/workflows/live_artifacts.yml @@ -70,9 +70,10 @@ jobs: runs-on: ubuntu-20.04 timeout-minutes: 90 steps: - - name: Checkout the Tag + - name: Sets the tag and repo variables (to build) run: | echo "TAG=${{ github.event.inputs.ref }}" >> $GITHUB_ENV + echo "REPO_TO_BUILD=${{ github.event.inputs.repo }}" >> $GITHUB_ENV - uses: actions/checkout@5a4ac9002d0be2fb38bd78e4b4dbde5606d7042f with: submodules: "recursive" @@ -84,7 +85,8 @@ jobs: run: | mkdir -p ${GITHUB_WORKSPACE}/artifacts docker run -e LIVE=1 -e PAT=${{ secrets.GITHUB_TOKEN }} \ - -e TAG=$TAG -v ${GITHUB_WORKSPACE}:/workspace \ + -e TAG=$TAG -e REPO_TO_BUILD=$REPO_TO_BUILD + -v ${GITHUB_WORKSPACE}:/workspace \ -v ${GITHUB_WORKSPACE}/artifacts:/root/rpmbuild \ nanocurrency/nano-env:centos /bin/bash -c "ci/build-centos.sh" - name: Deploy Artifacts diff --git a/ci/build-centos.sh b/ci/build-centos.sh index 6f9c7cf49e..39157c316c 100755 --- a/ci/build-centos.sh +++ b/ci/build-centos.sh @@ -2,9 +2,10 @@ TAG=$(echo $TAG) VERSIONS=${TAG//V/} RELEASE=$(echo $CI_JOB_ID) +REPO_TO_BUILD=$(echo $REPO_TO_BUILD) run_source() { - ./util/makesrc $TAG $(echo $PAT) + ./util/makesrc $TAG $(echo $PAT) $REPO_TO_BUILD } run_build() { diff --git a/util/makesrc b/util/makesrc index ca0a32aac3..a4e22ce8bf 100755 --- a/util/makesrc +++ b/util/makesrc @@ -4,21 +4,23 @@ # personal access token allows around rate limit if [ -e $2 ]; then - echo "makesrc " >&2 - echo " tag valid for nanocurrency/nano-node" >&2 + echo "makesrc " >&2 + echo " tag valid for " >&2 echo " pat personal access token" >&2 + echo " repo repository to build" >&2 exit 1 fi TAG="$1" PAT="$2" +repository="${3:-nanocurrency/nano-node}" VERSION=$(echo $TAG | sed 's/V//') TAG_DATE="" VERSION_MAJOR=$(echo $VERSION | cut -d "." -f 1) scriptDir="$(dirname "$(readlink -f "${BASH_SOURCE[0]}")")" function make_source() { - git clone --recursive --single-branch --branch ${TAG} https://github.com/nanocurrency/nano-node nano-$VERSION + git clone --recursive --single-branch --branch "${TAG}" "https://github.com/${repository}" "nano-${VERSION}" cd nano-$VERSION git fetch --tags COUNT=$(git tag -l "${TAG}" | wc -l) From 234e15d39ba6ed8162081e91ddbe4bd70c582a8b Mon Sep 17 00:00:00 2001 From: Thiago Silva Date: Fri, 20 May 2022 13:56:14 -0300 Subject: [PATCH 06/34] Removes the changelog generation from the RPM workflow --- .github/workflows/live_artifacts.yml | 3 +-- ci/build-centos.sh | 2 +- util/makesrc | 25 +++---------------------- 3 files changed, 5 insertions(+), 25 deletions(-) diff --git a/.github/workflows/live_artifacts.yml b/.github/workflows/live_artifacts.yml index de1fc72f85..600700a059 100644 --- a/.github/workflows/live_artifacts.yml +++ b/.github/workflows/live_artifacts.yml @@ -84,8 +84,7 @@ jobs: - name: Build Artifact run: | mkdir -p ${GITHUB_WORKSPACE}/artifacts - docker run -e LIVE=1 -e PAT=${{ secrets.GITHUB_TOKEN }} \ - -e TAG=$TAG -e REPO_TO_BUILD=$REPO_TO_BUILD + docker run -e LIVE=1 -e TAG=$TAG -e REPO_TO_BUILD=$REPO_TO_BUILD \ -v ${GITHUB_WORKSPACE}:/workspace \ -v ${GITHUB_WORKSPACE}/artifacts:/root/rpmbuild \ nanocurrency/nano-env:centos /bin/bash -c "ci/build-centos.sh" diff --git a/ci/build-centos.sh b/ci/build-centos.sh index 39157c316c..37e5ebb724 100755 --- a/ci/build-centos.sh +++ b/ci/build-centos.sh @@ -5,7 +5,7 @@ RELEASE=$(echo $CI_JOB_ID) REPO_TO_BUILD=$(echo $REPO_TO_BUILD) run_source() { - ./util/makesrc $TAG $(echo $PAT) $REPO_TO_BUILD + ./util/makesrc $TAG $REPO_TO_BUILD } run_build() { diff --git a/util/makesrc b/util/makesrc index a4e22ce8bf..9ba5ba9e84 100755 --- a/util/makesrc +++ b/util/makesrc @@ -1,19 +1,14 @@ #!/bin/bash -# makesrc -# personal access token allows around rate limit - if [ -e $2 ]; then - echo "makesrc " >&2 + echo "makesrc " >&2 echo " tag valid for " >&2 - echo " pat personal access token" >&2 echo " repo repository to build" >&2 exit 1 fi TAG="$1" -PAT="$2" -repository="${3:-nanocurrency/nano-node}" +repository="${2:-nanocurrency/nano-node}" VERSION=$(echo $TAG | sed 's/V//') TAG_DATE="" VERSION_MAJOR=$(echo $VERSION | cut -d "." -f 1) @@ -41,28 +36,14 @@ function source_information() { DATE=$(git log --tags --simplify-by-decoration --pretty="format:%ai %d" | head -1 | cut -d " " -f1-3) COMMIT=$(git log | head -1 | cut -d " " -f 2) TAG_DATE=$(TZ=UTC date -d"$DATE" +%s) - -# ( -# eval "$(scl enable rh-python38 'echo -e "source /opt/rh/rh-python38/enable\n"')" -# python -m pip install PyGithub mdutils -# -# python ${scriptDir}/changelog.py -p ${PAT} -t ${TAG} -m full -# -# if [ ! -s CHANGELOG.md ]; then -# echo "CHANGELOG not generated" -# exit 1 -# fi -# exit 0 -# ) || exit 1 - export TAG_DATE } function cleanup_source() { mv nano-$VERSION.tar.gz ~/. echo "ARCHIVE MOVDED TO HOME..." rm -fr nano-$TAG/ - } + function tarball_creation() { cd .. ARCHIVE_FILE_NAME="nano-${VERSION}.tar.gz" From 2cc4f03ee4ad0f04d69d496bb2d642e344358460 Mon Sep 17 00:00:00 2001 From: Thiago Silva Date: Mon, 23 May 2022 15:32:58 -0300 Subject: [PATCH 07/34] Sets the workflow scripts to use its ref/repo --- .github/workflows/live_artifacts.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/live_artifacts.yml b/.github/workflows/live_artifacts.yml index 600700a059..94af9500d4 100644 --- a/.github/workflows/live_artifacts.yml +++ b/.github/workflows/live_artifacts.yml @@ -77,8 +77,8 @@ jobs: - uses: actions/checkout@5a4ac9002d0be2fb38bd78e4b4dbde5606d7042f with: submodules: "recursive" - ref: ${{ github.event.inputs.ref }} - repository: ${{ github.event.inputs.repo }} + ref: ${{ github.ref }} + repository: ${{ github.repository }} - name: CentOS Base run: ci/build-docker-image.sh docker/ci/Dockerfile-centos nanocurrency/nano-env:centos - name: Build Artifact From 3fd31ee84143163bff35f66f1b5c4a048b5a3b06 Mon Sep 17 00:00:00 2001 From: Thiago Silva Date: Mon, 23 May 2022 17:43:22 -0300 Subject: [PATCH 08/34] Better name for the RPM release variable --- .github/workflows/live_artifacts.yml | 2 +- ci/build-centos.sh | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.github/workflows/live_artifacts.yml b/.github/workflows/live_artifacts.yml index 94af9500d4..bd429e6e55 100644 --- a/.github/workflows/live_artifacts.yml +++ b/.github/workflows/live_artifacts.yml @@ -84,7 +84,7 @@ jobs: - name: Build Artifact run: | mkdir -p ${GITHUB_WORKSPACE}/artifacts - docker run -e LIVE=1 -e TAG=$TAG -e REPO_TO_BUILD=$REPO_TO_BUILD \ + docker run -e LIVE=1 -e TAG=$TAG -e REPO_TO_BUILD=$REPO_TO_BUILD -e RPM_RELEASE=1 \ -v ${GITHUB_WORKSPACE}:/workspace \ -v ${GITHUB_WORKSPACE}/artifacts:/root/rpmbuild \ nanocurrency/nano-env:centos /bin/bash -c "ci/build-centos.sh" diff --git a/ci/build-centos.sh b/ci/build-centos.sh index 37e5ebb724..117a75555e 100755 --- a/ci/build-centos.sh +++ b/ci/build-centos.sh @@ -1,7 +1,7 @@ #!/usr/bin/env bash TAG=$(echo $TAG) VERSIONS=${TAG//V/} -RELEASE=$(echo $CI_JOB_ID) +RPM_RELEASE=$(echo $RPM_RELEASE) REPO_TO_BUILD=$(echo $REPO_TO_BUILD) run_source() { @@ -25,7 +25,7 @@ run_update() { echo "Updating \"${outfile}\"..." rm -f "${file}.new" - awk -v srch="@VERSION@" -v repl="$VERSIONS" -v srch2="@RELEASE@" -v repl2="$RELEASE" '{ sub(srch,repl,$0); sub(srch2,repl2, $0); print $0}' <${file} >${file}.new + awk -v srch="@VERSION@" -v repl="$VERSIONS" -v srch2="@RELEASE@" -v repl2="$RPM_RELEASE" '{ sub(srch,repl,$0); sub(srch2,repl2, $0); print $0}' <${file} >${file}.new rm -fr "${outfile}" cat "${file}.new" >"${outfile}" rm -f "${file}.new" From d277eb551b6d4d5eee1a0d25ea7d0616a066c97b Mon Sep 17 00:00:00 2001 From: Thiago Silva Date: Mon, 6 Jun 2022 17:10:48 -0300 Subject: [PATCH 09/34] Improve maksrc build-centos.sh scripts --- ci/build-centos.sh | 8 +++++--- util/makesrc | 22 ++++++++++++---------- 2 files changed, 17 insertions(+), 13 deletions(-) diff --git a/ci/build-centos.sh b/ci/build-centos.sh index 117a75555e..bfd3f70716 100755 --- a/ci/build-centos.sh +++ b/ci/build-centos.sh @@ -1,6 +1,6 @@ #!/usr/bin/env bash TAG=$(echo $TAG) -VERSIONS=${TAG//V/} +VERSION=$(echo "${TAG}" | sed 's/V//' | sed 's/-/_/g') RPM_RELEASE=$(echo $RPM_RELEASE) REPO_TO_BUILD=$(echo $REPO_TO_BUILD) @@ -10,7 +10,7 @@ run_source() { run_build() { mkdir -p ~/rpmbuild/SOURCES/ - mv -f ~/nano-${VERSIONS}.tar.gz ~/rpmbuild/SOURCES/. + mv -f ~/nano-${VERSION}.tar.gz ~/rpmbuild/SOURCES/. if [ "${LIVE:-}" == "1" ]; then scl enable devtoolset-7 'rpmbuild -ba nanocurrency.spec' else @@ -25,7 +25,7 @@ run_update() { echo "Updating \"${outfile}\"..." rm -f "${file}.new" - awk -v srch="@VERSION@" -v repl="$VERSIONS" -v srch2="@RELEASE@" -v repl2="$RPM_RELEASE" '{ sub(srch,repl,$0); sub(srch2,repl2, $0); print $0}' <${file} >${file}.new + awk -v srch="@VERSION@" -v repl="$VERSION" -v srch2="@RELEASE@" -v repl2="$RPM_RELEASE" '{ sub(srch,repl,$0); sub(srch2,repl2, $0); print $0}' <${file} >${file}.new rm -fr "${outfile}" cat "${file}.new" >"${outfile}" rm -f "${file}.new" @@ -33,6 +33,8 @@ run_update() { done } +set -x + run_update run_source run_build diff --git a/util/makesrc b/util/makesrc index 9ba5ba9e84..8c33e71419 100755 --- a/util/makesrc +++ b/util/makesrc @@ -1,26 +1,25 @@ #!/bin/bash -if [ -e $2 ]; then +if [ -e "${2}" ]; then echo "makesrc " >&2 echo " tag valid for " >&2 echo " repo repository to build" >&2 exit 1 fi -TAG="$1" +TAG="${1}" repository="${2:-nanocurrency/nano-node}" -VERSION=$(echo $TAG | sed 's/V//') +VERSION=$(echo "${TAG}" | sed 's/V//' | sed 's/-/_/g') TAG_DATE="" -VERSION_MAJOR=$(echo $VERSION | cut -d "." -f 1) scriptDir="$(dirname "$(readlink -f "${BASH_SOURCE[0]}")")" function make_source() { git clone --recursive --single-branch --branch "${TAG}" "https://github.com/${repository}" "nano-${VERSION}" - cd nano-$VERSION + cd "nano-${VERSION}" git fetch --tags COUNT=$(git tag -l "${TAG}" | wc -l) if [ "$COUNT" -eq 0 ]; then - echo "tag $TAG not found" + echo "tag ${TAG} not found" exit 1 else git checkout "${TAG}" @@ -35,13 +34,13 @@ function make_source() { function source_information() { DATE=$(git log --tags --simplify-by-decoration --pretty="format:%ai %d" | head -1 | cut -d " " -f1-3) COMMIT=$(git log | head -1 | cut -d " " -f 2) - TAG_DATE=$(TZ=UTC date -d"$DATE" +%s) + TAG_DATE=$(TZ=UTC date -d"${DATE}" +%s) export TAG_DATE } function cleanup_source() { - mv nano-$VERSION.tar.gz ~/. + mv "nano-${VERSION}.tar.gz" ~/. echo "ARCHIVE MOVDED TO HOME..." - rm -fr nano-$TAG/ + rm -fr "nano-${VERSION}"/ } function tarball_creation() { @@ -61,7 +60,10 @@ function tarball_creation() { tarArgs=("${tarArgs[@]}" --mtime="@${TAG_DATE}") fi fi - TZ=UTC LANG=C LC_ALL=C tar "${tarArgs[@]}" -cvf - nano-${VERSION} | TZ=UTC gzip --no-name -9c >"${ARCHIVE_FILE_NAME}" || exit 1 + TZ=UTC LANG=C LC_ALL=C tar "${tarArgs[@]}" -cvf - "nano-${VERSION}" | TZ=UTC gzip --no-name -9c >"${ARCHIVE_FILE_NAME}" || exit 1 } + +set -x + make_source cleanup_source From 423f5366b6b81aa2ee082ad095bcdf294a212dbc Mon Sep 17 00:00:00 2001 From: Thiago Silva Date: Thu, 9 Jun 2022 08:17:30 -0300 Subject: [PATCH 10/34] Missing S3_BUILD_DIRECTORY var definition --- .github/workflows/live_artifacts.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/live_artifacts.yml b/.github/workflows/live_artifacts.yml index bd429e6e55..f797b89310 100644 --- a/.github/workflows/live_artifacts.yml +++ b/.github/workflows/live_artifacts.yml @@ -92,6 +92,7 @@ jobs: run: ci/actions/deploy.sh env: LINUX_RPM: 1 + S3_BUILD_DIRECTORY: ${{ secrets.S3_BUILD_DIRECTORY }} AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }} AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }} AWS_DEFAULT_REGION: us-east-2 From 7c074748fe6ecdfba234e9ec8f5476a7f8d29f78 Mon Sep 17 00:00:00 2001 From: Thiago Silva Date: Mon, 13 Jun 2022 17:10:37 -0300 Subject: [PATCH 11/34] Fix the checksum basenames --- ci/actions/deploy.sh | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/ci/actions/deploy.sh b/ci/actions/deploy.sh index 6895108c9d..19e860b45d 100755 --- a/ci/actions/deploy.sh +++ b/ci/actions/deploy.sh @@ -24,14 +24,14 @@ if [[ "$OS" == 'Linux' && "$IS_RPM_DEPLOY" -eq "1" ]]; then RPMS=$(find ${GITHUB_WORKSPACE}/artifacts/RPMS -type f -name '*.rpm') SRPMS=$(find ${GITHUB_WORKSPACE}/artifacts/SRPMS -type f -name '*.src.rpm') for rpm in $RPMS; do - sha256sum $rpm > "${GITHUB_WORKSPACE}/${rpm}.sha256" - aws s3 cp "${rpm}" s3://repo.nano.org/$DIRECTORY/binaries/$(basename "${rpm}") --grants read=uri=http://acs.amazonaws.com/groups/global/AllUsers - aws s3 cp "${GITHUB_WORKSPACE}/${rpm}.sha256" s3://repo.nano.org/$DIRECTORY/binaries/$(basename "${rpm}.sha256") --grants read=uri=http://acs.amazonaws.com/groups/global/AllUsers + sha256sum ${rpm} > ${GITHUB_WORKSPACE}/$(basename "${rpm}.sha256") + aws s3 cp ${rpm} s3://repo.nano.org/$DIRECTORY/binaries/$(basename "${rpm}") --grants read=uri=http://acs.amazonaws.com/groups/global/AllUsers + aws s3 cp ${GITHUB_WORKSPACE}/$(basename "${rpm}.sha256") s3://repo.nano.org/$DIRECTORY/binaries/$(basename "${rpm}.sha256") --grants read=uri=http://acs.amazonaws.com/groups/global/AllUsers done for srpm in $SRPMS; do - sha256sum $srpm > "${GITHUB_WORKSPACE}/${srpm}.sha256" - aws s3 cp "${srpm}" s3://repo.nano.org/$DIRECTORY/source/$(basename "${srpm}") --grants read=uri=http://acs.amazonaws.com/groups/global/AllUsers - aws s3 cp "${GITHUB_WORKSPACE}/${srpm}.sha256" s3://repo.nano.org/$DIRECTORY/source/$(basename "${srpm}.sha256") --grants read=uri=http://acs.amazonaws.com/groups/global/AllUsers + sha256sum ${srpm} > ${GITHUB_WORKSPACE}/$(basename "${srpm}).sha256") + aws s3 cp ${srpm} s3://repo.nano.org/$DIRECTORY/source/$(basename "${srpm}") --grants read=uri=http://acs.amazonaws.com/groups/global/AllUsers + aws s3 cp ${GITHUB_WORKSPACE}/$(basename "${srpm}).sha256") s3://repo.nano.org/$DIRECTORY/source/$(basename "${srpm}.sha256") --grants read=uri=http://acs.amazonaws.com/groups/global/AllUsers done elif [[ "$OS" == 'Linux' ]]; then sha256sum $GITHUB_WORKSPACE/build/nano-node-*-Linux.tar.bz2 >$GITHUB_WORKSPACE/nano-node-$TAG-Linux.tar.bz2.sha256 From a21caaf8412e7d9a5e2f8bd61fe9811173544cda Mon Sep 17 00:00:00 2001 From: JerzyStanislawski <49572068+JerzyStanislawski@users.noreply.github.com> Date: Fri, 24 Jun 2022 13:40:48 +0200 Subject: [PATCH 12/34] confirmation_height_clear cli account param (#3836) * confirmation_height_clear cli account param * Add back missing password option * Improve the error/help messages to the required account option - Improve the error message to say the account can be 'all' - Improve the confirmation_height_clear help message to inform the value 'all' can be passed to clear all accounts Co-authored-by: Thiago Silva --- nano/node/cli.cpp | 22 +++++++++++++--------- 1 file changed, 13 insertions(+), 9 deletions(-) diff --git a/nano/node/cli.cpp b/nano/node/cli.cpp index 79b2fc1205..ad8d64d381 100644 --- a/nano/node/cli.cpp +++ b/nano/node/cli.cpp @@ -57,7 +57,7 @@ void nano::add_node_options (boost::program_options::options_description & descr ("online_weight_clear", "Clear online weight history records") ("peer_clear", "Clear online peers database dump") ("unchecked_clear", "Clear unchecked blocks") - ("confirmation_height_clear", "Clear confirmation height") + ("confirmation_height_clear", "Clear confirmation height. Requires an option that can be 'all' to clear all accounts") ("final_vote_clear", "Clear final votes") ("rebuild_database", "Rebuild LMDB database with vacuum for best compaction") ("migrate_database_lmdb_to_rocksdb", "Migrates LMDB database to RocksDB") @@ -321,7 +321,7 @@ std::error_code nano::handle_node_options (boost::program_options::variables_map } else { - std::cerr << "wallet_add command requires one option and one option and optionally one option\n"; + std::cerr << "account_create command requires one option and optionally one option\n"; ec = nano::error_cli::invalid_arguments; } } @@ -579,10 +579,9 @@ std::error_code nano::handle_node_options (boost::program_options::variables_map nano::inactive_node node (data_path, node_flags); if (!node.node->init_error ()) { - auto account_it = vm.find ("account"); - if (account_it != vm.cend ()) + if (vm.count ("account") == 1) { - auto account_str = account_it->second.as (); + auto account_str = vm["account"].as (); nano::account account; if (!account.decode_account (account_str)) { @@ -609,17 +608,22 @@ std::error_code nano::handle_node_options (boost::program_options::variables_map ec = nano::error_cli::generic; } } + else if (account_str == "all") + { + auto transaction (node.node->store.tx_begin_write ()); + 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; + } else { - std::cerr << "Invalid account id\n"; + std::cerr << "Specify either valid account id or 'all'\n"; ec = nano::error_cli::invalid_arguments; } } else { - auto transaction (node.node->store.tx_begin_write ()); - 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; + std::cerr << "confirmation_height_clear command requires one option that may contain an account or the value 'all'\n"; + ec = nano::error_cli::invalid_arguments; } } else From 30ebf6cf9809d9607d8a776d6b9f241025c1784e Mon Sep 17 00:00:00 2001 From: Thiago Silva <82097354+thsfs@users.noreply.github.com> Date: Mon, 27 Jun 2022 17:28:12 -0300 Subject: [PATCH 13/34] Removes references to Travis CI from nano-node (#3755) * Remove unused Travis CI script * Removes deploy-docker.sh as it is unused * Replacing mention to Travis to CI instead --- .github/workflows/beta_artifacts.yml | 8 +-- .github/workflows/coverage.yml | 2 +- .github/workflows/live_artifacts.yml | 8 +-- .github/workflows/test_network_artifacts.yml | 8 +-- .github/workflows/tests.yml | 4 +- CMakeLists.txt | 2 +- ci/actions/linux/docker-impl/docker-common.sh | 14 ++--- ci/actions/windows/build.ps1 | 2 +- ci/{build-travis.sh => build-ci.sh} | 0 ci/deploy-docker.sh | 54 ------------------- ci/deploy-travis.sh | 18 ------- docker/node/Dockerfile | 2 +- 12 files changed, 25 insertions(+), 97 deletions(-) rename ci/{build-travis.sh => build-ci.sh} (100%) delete mode 100755 ci/deploy-docker.sh delete mode 100755 ci/deploy-travis.sh diff --git a/.github/workflows/beta_artifacts.yml b/.github/workflows/beta_artifacts.yml index d29800a147..d3371e3b2a 100644 --- a/.github/workflows/beta_artifacts.yml +++ b/.github/workflows/beta_artifacts.yml @@ -32,7 +32,7 @@ jobs: - name: Fetch Deps run: ci/actions/osx/install_deps.sh - name: Build Artifact - run: TRAVIS_TAG=${TAG} ci/build-deploy.sh "/tmp/qt/lib/cmake/Qt5"; + run: CI_TAG=${TAG} ci/build-deploy.sh "/tmp/qt/lib/cmake/Qt5"; - name: Deploy Artifact run: ci/actions/deploy.sh env: @@ -58,7 +58,7 @@ jobs: COMPILER: gcc run: ci/actions/linux/install_deps.sh - name: Build Artifact - run: docker run -v ${GITHUB_WORKSPACE}:/workspace nanocurrency/nano-env:gcc /bin/bash -c "cd /workspace && BETA=1 TRAVIS_TAG=${TAG} ci/build-deploy.sh /usr/lib/x86_64-linux-gnu/cmake/Qt5" + run: docker run -v ${GITHUB_WORKSPACE}:/workspace nanocurrency/nano-env:gcc /bin/bash -c "cd /workspace && BETA=1 CI_TAG=${TAG} ci/build-deploy.sh /usr/lib/x86_64-linux-gnu/cmake/Qt5" - name: Deploy Artifact run: ci/actions/deploy.sh env: @@ -84,10 +84,10 @@ jobs: COMPILER: gcc run: ci/actions/linux/install_deps.sh - name: Build Docker (nanocurrency/nano-beta) - run: TRAVIS_TAG=${TAG} ci/actions/linux/docker-build.sh + run: CI_TAG=${TAG} ci/actions/linux/docker-build.sh - name: Deploy Docker Hub (nanocurrency/nano-beta) if: ${{ github.repository == 'nanocurrency/nano-node' }} - run: TRAVIS_TAG=${TAG} ci/actions/linux/docker-deploy.sh + run: CI_TAG=${TAG} ci/actions/linux/docker-deploy.sh env: DOCKER_PASSWORD: ${{ secrets.DOCKER_PASSWORD }} - name: Login to ghcr.io diff --git a/.github/workflows/coverage.yml b/.github/workflows/coverage.yml index b0a9f5f3ec..3b375d0738 100644 --- a/.github/workflows/coverage.yml +++ b/.github/workflows/coverage.yml @@ -40,7 +40,7 @@ jobs: - 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 + run: ./ci/build-ci.sh /usr/lib/x86_64-linux=gnu/cmake/Qt5 - uses: coverallsapp/github-action@8cbef1dea373ebce56de0a14c68d6267baa10b44 with: github-token: ${{ secrets.github_token }} diff --git a/.github/workflows/live_artifacts.yml b/.github/workflows/live_artifacts.yml index f797b89310..9fce1f1db8 100644 --- a/.github/workflows/live_artifacts.yml +++ b/.github/workflows/live_artifacts.yml @@ -31,7 +31,7 @@ jobs: - name: Fetch Deps run: ci/actions/osx/install_deps.sh - name: Build Artifact - run: TRAVIS_TAG=${TAG} ci/build-deploy.sh "/tmp/qt/lib/cmake/Qt5"; + run: CI_TAG=${TAG} ci/build-deploy.sh "/tmp/qt/lib/cmake/Qt5"; - name: Deploy Artifact run: ci/actions/deploy.sh env: @@ -57,7 +57,7 @@ jobs: COMPILER: gcc run: ci/actions/linux/install_deps.sh - name: Build Artifact - run: docker run -v ${GITHUB_WORKSPACE}:/workspace nanocurrency/nano-env:gcc /bin/bash -c "cd /workspace && TRAVIS_TAG=${TAG} ci/build-deploy.sh /usr/lib/x86_64-linux-gnu/cmake/Qt5" + run: docker run -v ${GITHUB_WORKSPACE}:/workspace nanocurrency/nano-env:gcc /bin/bash -c "cd /workspace && CI_TAG=${TAG} ci/build-deploy.sh /usr/lib/x86_64-linux-gnu/cmake/Qt5" - name: Deploy Artifact run: ci/actions/deploy.sh env: @@ -114,10 +114,10 @@ jobs: COMPILER: gcc run: ci/actions/linux/install_deps.sh - name: Build Docker (nanocurrency/nano) - run: TRAVIS_TAG=${TAG} ci/actions/linux/docker-build.sh + run: CI_TAG=${TAG} ci/actions/linux/docker-build.sh - name: Deploy Docker Hub (nanocurrency/nano) if: ${{ github.repository == 'nanocurrency/nano-node' }} - run: TRAVIS_TAG=${TAG} ci/actions/linux/docker-deploy.sh + run: CI_TAG=${TAG} ci/actions/linux/docker-deploy.sh env: DOCKER_PASSWORD: ${{ secrets.DOCKER_PASSWORD }} - name: Login to ghcr.io diff --git a/.github/workflows/test_network_artifacts.yml b/.github/workflows/test_network_artifacts.yml index cd79847d18..c84edff7f1 100644 --- a/.github/workflows/test_network_artifacts.yml +++ b/.github/workflows/test_network_artifacts.yml @@ -32,7 +32,7 @@ jobs: - name: Fetch Deps run: ci/actions/osx/install_deps.sh - name: Build Artifact - run: TRAVIS_TAG=${TAG} ci/build-deploy.sh "/tmp/qt/lib/cmake/Qt5"; + run: CI_TAG=${TAG} ci/build-deploy.sh "/tmp/qt/lib/cmake/Qt5"; - name: Deploy Artifact run: ci/actions/deploy.sh env: @@ -58,7 +58,7 @@ jobs: COMPILER: gcc run: ci/actions/linux/install_deps.sh - name: Build Artifact - run: docker run -e TEST -v ${GITHUB_WORKSPACE}:/workspace nanocurrency/nano-env:gcc /bin/bash -c "cd /workspace && TRAVIS_TAG=${TAG} ci/build-deploy.sh /usr/lib/x86_64-linux-gnu/cmake/Qt5" + run: docker run -e TEST -v ${GITHUB_WORKSPACE}:/workspace nanocurrency/nano-env:gcc /bin/bash -c "cd /workspace && CI_TAG=${TAG} ci/build-deploy.sh /usr/lib/x86_64-linux-gnu/cmake/Qt5" - name: Deploy Artifact run: ci/actions/deploy.sh env: @@ -84,10 +84,10 @@ jobs: COMPILER: gcc run: ci/actions/linux/install_deps.sh - name: Build Docker (nanocurrency/nano) - run: TRAVIS_TAG=${TAG} ci/actions/linux/docker-build.sh + run: CI_TAG=${TAG} ci/actions/linux/docker-build.sh - name: Deploy Docker Hub (nanocurrency/nano-test) if: ${{ github.repository == 'nanocurrency/nano-node' }} - run: TRAVIS_TAG=${TAG} ci/actions/linux/docker-deploy.sh + run: CI_TAG=${TAG} ci/actions/linux/docker-deploy.sh env: DOCKER_PASSWORD: ${{ secrets.DOCKER_PASSWORD }} - name: Login to ghcr.io diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml index b0902cc164..e80d3d4d57 100644 --- a/.github/workflows/tests.yml +++ b/.github/workflows/tests.yml @@ -28,7 +28,7 @@ jobs: - name: Fetch Deps run: TEST=1 ci/actions/osx/install_deps.sh - name: Build Tests - run: ci/build-travis.sh "/tmp/qt/lib/cmake/Qt5"; + run: ci/build-ci.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 . @@ -61,7 +61,7 @@ jobs: - name: Fetch Deps run: ci/actions/linux/install_deps.sh - 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" + run: docker run -e TEST_USE_ROCKSDB -e RELEASE -v ${PWD}:/workspace nanocurrency/nano-env:${{ matrix.COMPILER }} /bin/bash -c "cd /workspace && ./ci/build-ci.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 ." diff --git a/CMakeLists.txt b/CMakeLists.txt index 0af358ddff..cff904680a 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -53,7 +53,7 @@ set(CPACK_PACKAGE_VERSION_PRE_RELEASE "99") set(CPACK_PACKAGE_VENDOR "Nano Currency") if(CI_BUILD) - set(TAG_VERSION_STRING "$ENV{TRAVIS_TAG}") + set(TAG_VERSION_STRING "$ENV{CI_TAG}") else() set(TAG_VERSION_STRING "V${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR}") diff --git a/ci/actions/linux/docker-impl/docker-common.sh b/ci/actions/linux/docker-impl/docker-common.sh index 0be3293033..6a32bc55d5 100755 --- a/ci/actions/linux/docker-impl/docker-common.sh +++ b/ci/actions/linux/docker-impl/docker-common.sh @@ -4,13 +4,13 @@ set -e set -a scripts="$PWD/ci" -TRAVIS_BRANCH=$(git branch | cut -f2 -d' ') +CI_BRANCH=$(git branch | cut -f2 -d' ') tags=() -if [ -n "$TRAVIS_TAG" ]; then - tags+=("$TRAVIS_TAG") -elif [ -n "$TRAVIS_BRANCH" ]; then - TRAVIS_TAG=$TRAVIS_BRANCH - tags+=("$TRAVIS_BRANCH") +if [ -n "$CI_TAG" ]; then + tags+=("$CI_TAG") +elif [ -n "$CI_BRANCH" ]; then + CI_TAG=$CI_BRANCH + tags+=("$CI_BRANCH") fi if [[ "$GITHUB_WORKFLOW" = "Live" ]]; then echo "Live" @@ -34,7 +34,7 @@ docker_build() { if [[ "$GITHUB_WORKFLOW" != "Develop" ]]; then ghcr_image_name="ghcr.io/${GITHUB_REPOSITORY}/nano${network_tag_suffix}" - "$scripts"/build-docker-image.sh docker/node/Dockerfile "$docker_image_name" --build-arg NETWORK="$network" --build-arg CI_BUILD=true --build-arg TRAVIS_TAG="$TRAVIS_TAG" + "$scripts"/build-docker-image.sh docker/node/Dockerfile "$docker_image_name" --build-arg NETWORK="$network" --build-arg CI_BUILD=true --build-arg CI_TAG="$CI_TAG" for tag in "${tags[@]}"; do # Sanitize docker tag # https://docs.docker.com/engine/reference/commandline/tag/ diff --git a/ci/actions/windows/build.ps1 b/ci/actions/windows/build.ps1 index 5001074184..44d86c1328 100644 --- a/ci/actions/windows/build.ps1 +++ b/ci/actions/windows/build.ps1 @@ -14,7 +14,7 @@ if (${env:artifact} -eq 1) { } $env:NANO_SHARED_BOOST = "ON" $env:NANO_TEST = "-DNANO_TEST=OFF" - $env:TRAVIS_TAG = ${env:TAG} + $env:CI_TAG = ${env:TAG} $env:CI = "-DCI_BUILD=ON" $env:RUN = "artifact" diff --git a/ci/build-travis.sh b/ci/build-ci.sh similarity index 100% rename from ci/build-travis.sh rename to ci/build-ci.sh diff --git a/ci/deploy-docker.sh b/ci/deploy-docker.sh deleted file mode 100755 index fc2fd085d9..0000000000 --- a/ci/deploy-docker.sh +++ /dev/null @@ -1,54 +0,0 @@ -#!/bin/bash -set -e - -scripts="$(dirname "$0")" - -if [ -n "$DOCKER_PASSWORD" ]; then - echo "$DOCKER_PASSWORD" | docker login -u nanoreleaseteam --password-stdin - - # We push this just so it can be a cache next time - if [[ "$TRAVIS_BRANCH" == "master" || "$TRAVIS_BRANCH" == "docker_cache" ]] && [[ "${TRAVIS_BUILD_STAGE_NAME}" =~ 'Build' ]]; then - ci_image_name="nanocurrency/nano-env:$TRAVIS_JOB_NAME" - ci/build-docker-image.sh docker/ci/Dockerfile-$TRAVIS_JOB_NAME "$ci_image_name" - "$scripts"/custom-timeout.sh 30 docker push "$ci_image_name" - fi - - if [[ "$TRAVIS_BUILD_STAGE_NAME" == "Master_beta_docker" ]]; then - # quick build and tag beta network master - "$scripts"/custom-timeout.sh 30 docker build --build-arg NETWORK=beta --build-arg CI_BUILD=true --build-arg TRAVIS_TAG="$TRAVIS_TAG" -f docker/node/Dockerfile -t nanocurrency/nano-beta:master --cache-from nanocurrency/nano-beta:master . - "$scripts"/custom-timeout.sh 30 docker push nanocurrency/nano-beta:master - elif [[ "$TRAVIS_BUILD_STAGE_NAME" =~ "Artifacts" ]]; then - tags=() - if [[ "${TRAVIS_TAG}" =~ ("RC"|"DB") ]]; then - tags+=("$TRAVIS_TAG" latest latest-including-rc) - elif [ -n "$TRAVIS_TAG" ]; then - tags+=("$TRAVIS_TAG" latest latest-including-rc) - elif [ -n "$TRAVIS_BRANCH" ]; then - tags+=("$TRAVIS_BRANCH") - fi - - if [[ "$TRAVIS_JOB_NAME" =~ "live" ]]; then - network_tag_suffix='' - network="live" - cached='' - else - network_tag_suffix="-beta" - network="beta" - # use cache from Master_beta_docker to prevent rebuilds - cached="--cache-from=nanocurrency/nano-beta:master" - docker pull nanocurrency/nano-beta:master - fi - - docker_image_name="nanocurrency/nano${network_tag_suffix}" - "$scripts"/custom-timeout.sh 30 docker build "$cached" --build-arg NETWORK="$network" --build-arg CI_BUILD=true --build-arg TRAVIS_TAG="$TRAVIS_TAG" -f docker/node/Dockerfile -t "$docker_image_name" . - for tag in "${tags[@]}"; do - # Sanitize docker tag - # https://docs.docker.com/engine/reference/commandline/tag/ - tag="$(printf '%s' "$tag" | tr -c '[a-z][A-Z][0-9]_.-' -)" - if [ "$tag" != "latest" ]; then - docker tag "$docker_image_name" "${docker_image_name}:$tag" - fi - "$scripts"/custom-timeout.sh 30 docker push "${docker_image_name}:$tag" - done - fi -fi diff --git a/ci/deploy-travis.sh b/ci/deploy-travis.sh deleted file mode 100755 index 4a24eae9be..0000000000 --- a/ci/deploy-travis.sh +++ /dev/null @@ -1,18 +0,0 @@ -#!/bin/bash - -set -o errexit -set -o nounset -set -o xtrace -OS=$(uname) - -if [[ "${BETA-0}" -eq 1 ]]; then - BUILD="beta" -else - BUILD="live" -fi - -if [[ "$OS" == 'Linux' ]]; then - aws s3 cp $TRAVIS_BUILD_DIR/build/nano-node-*-Linux.tar.bz2 s3://$AWS_BUCKET/$BUILD/binaries/nano-node-$TRAVIS_TAG-Linux.tar.bz2 --grants read=uri=http://acs.amazonaws.com/groups/global/AllUsers -else - aws s3 cp $TRAVIS_BUILD_DIR/build/nano-node-*-Darwin.dmg s3://$AWS_BUCKET/$BUILD/binaries/nano-node-$TRAVIS_TAG-Darwin.dmg --grants read=uri=http://acs.amazonaws.com/groups/global/AllUsers -fi diff --git a/docker/node/Dockerfile b/docker/node/Dockerfile index 1f7d7b1414..825364cb92 100644 --- a/docker/node/Dockerfile +++ b/docker/node/Dockerfile @@ -1,7 +1,7 @@ FROM nanocurrency/nano-env:gcc ARG NETWORK=live -ARG TRAVIS_TAG=DEV_BUILD +ARG CI_TAG=DEV_BUILD ARG CI_BUILD=OFF ADD ./ /tmp/src From e17545d77dcc46ada057f89fa5985b802dae4f6c Mon Sep 17 00:00:00 2001 From: clemahieu Date: Mon, 11 Apr 2022 18:42:22 +0100 Subject: [PATCH 14/34] Bound the unchecked store after the initial bootstrap amount has been reached. This prevents the unchecked table size from increasing beyond reasonable bounds when it's in sync. # Conflicts: # nano/node/blockprocessor.cpp --- nano/node/blockprocessor.cpp | 63 ++++++++++++++++++++++++++++++++++++ nano/secure/ledger.cpp | 5 +++ nano/secure/ledger.hpp | 1 + 3 files changed, 69 insertions(+) diff --git a/nano/node/blockprocessor.cpp b/nano/node/blockprocessor.cpp index d8be9a42d7..98d3c9e4be 100644 --- a/nano/node/blockprocessor.cpp +++ b/nano/node/blockprocessor.cpp @@ -381,7 +381,28 @@ nano::process_return nano::block_processor::process_one (nano::write_transaction node.logger.try_log (boost::str (boost::format ("Gap previous for: %1%") % hash.to_string ())); } info_a.verified = result.verified; + + //<<<<<<< HEAD + // node.unchecked.put (block->previous (), info_a); + //======= + // if (info_a.modified == 0) + // { + // info_a.modified = nano::seconds_since_epoch (); + // } + // + // nano::unchecked_key unchecked_key (block->previous (), hash); + // if (node.ledger.bootstrap_weight_reached () && node.store.unchecked.count (transaction_a) > max) + // { + // node.store.unchecked.clear (transaction_a); + // } + // node.store.unchecked.put (transaction_a, unchecked_key, info_a); + // + //>>>>>>> d4a4299b (Bound the unchecked store after the initial bootstrap amount has been reached. This prevents the unchecked table size from increasing beyond reasonable bounds when it's in sync.) + + // No need to check for unchecked store size, it will be bounded by subsequent unchecked-in-memory feature + debug_assert (info_a.modified () != 0); node.unchecked.put (block->previous (), info_a); + events_a.events.emplace_back ([this, hash] (nano::transaction const & /* unused */) { this->node.gap_cache.add (hash); }); node.stats.inc (nano::stat::type::ledger, nano::stat::detail::gap_previous); break; @@ -393,7 +414,28 @@ nano::process_return nano::block_processor::process_one (nano::write_transaction node.logger.try_log (boost::str (boost::format ("Gap source for: %1%") % hash.to_string ())); } info_a.verified = result.verified; + + //<<<<<<< HEAD + // node.unchecked.put (node.ledger.block_source (transaction_a, *(block)), info_a); + //======= + // if (info_a.modified == 0) + // { + // info_a.modified = nano::seconds_since_epoch (); + // } + // + // nano::unchecked_key unchecked_key (node.ledger.block_source (transaction_a, *(block)), hash); + // if (node.ledger.bootstrap_weight_reached () && node.store.unchecked.count (transaction_a) > max) + // { + // node.store.unchecked.clear (transaction_a); + // } + // node.store.unchecked.put (transaction_a, unchecked_key, info_a); + // + //>>>>>>> d4a4299b (Bound the unchecked store after the initial bootstrap amount has been reached. This prevents the unchecked table size from increasing beyond reasonable bounds when it's in sync.) + + // No need to check for unchecked store size, it will be bounded by subsequent unchecked-in-memory feature + debug_assert (info_a.modified () != 0); node.unchecked.put (node.ledger.block_source (transaction_a, *(block)), info_a); + events_a.events.emplace_back ([this, hash] (nano::transaction const & /* unused */) { this->node.gap_cache.add (hash); }); node.stats.inc (nano::stat::type::ledger, nano::stat::detail::gap_source); break; @@ -405,7 +447,28 @@ nano::process_return nano::block_processor::process_one (nano::write_transaction node.logger.try_log (boost::str (boost::format ("Gap pending entries for epoch open: %1%") % hash.to_string ())); } info_a.verified = result.verified; + + //<<<<<<< HEAD + // node.unchecked.put (block->account (), info_a); // Specific unchecked key starting with epoch open block account public key + //======= + // if (info_a.modified == 0) + // { + // info_a.modified = nano::seconds_since_epoch (); + // } + // + // nano::unchecked_key unchecked_key (block->account (), hash); // Specific unchecked key starting with epoch open block account public key + // if (node.ledger.bootstrap_weight_reached () && node.store.unchecked.count (transaction_a) > max) + // { + // node.store.unchecked.clear (transaction_a); + // } + // node.store.unchecked.put (transaction_a, unchecked_key, info_a); + // + //>>>>>>> d4a4299b (Bound the unchecked store after the initial bootstrap amount has been reached. This prevents the unchecked table size from increasing beyond reasonable bounds when it's in sync.) + + // No need to check for unchecked store size, it will be bounded by subsequent unchecked-in-memory feature + debug_assert (info_a.modified () != 0); node.unchecked.put (block->account (), info_a); // Specific unchecked key starting with epoch open block account public key + node.stats.inc (nano::stat::type::ledger, nano::stat::detail::gap_source); break; } diff --git a/nano/secure/ledger.cpp b/nano/secure/ledger.cpp index 4eda74d089..a52103c298 100644 --- a/nano/secure/ledger.cpp +++ b/nano/secure/ledger.cpp @@ -1589,6 +1589,11 @@ bool nano::ledger::migrate_lmdb_to_rocksdb (boost::filesystem::path const & data return error; } +bool nano::ledger::bootstrap_weight_reached () const +{ + return cache.block_count >= bootstrap_weight_max_blocks; +} + nano::uncemented_info::uncemented_info (nano::block_hash const & cemented_frontier, nano::block_hash const & frontier, nano::account const & account) : cemented_frontier (cemented_frontier), frontier (frontier), account (account) { diff --git a/nano/secure/ledger.hpp b/nano/secure/ledger.hpp index a19affbbd4..3f6857ad8d 100644 --- a/nano/secure/ledger.hpp +++ b/nano/secure/ledger.hpp @@ -70,6 +70,7 @@ class ledger final nano::link const & epoch_link (nano::epoch) const; std::multimap> unconfirmed_frontiers () const; bool migrate_lmdb_to_rocksdb (boost::filesystem::path const &) const; + bool bootstrap_weight_reached () const; static nano::uint128_t const unit; nano::ledger_constants & constants; nano::store & store; From ac999f2395f2f12888edea18012ddc775f7ca75e Mon Sep 17 00:00:00 2001 From: Dimitrios Siganos Date: Tue, 26 Apr 2022 03:42:16 +0100 Subject: [PATCH 15/34] If multiple handshake queries are received then close the socket --- nano/node/bootstrap/bootstrap_server.cpp | 14 ++++++++++++++ nano/node/bootstrap/bootstrap_server.hpp | 1 + 2 files changed, 15 insertions(+) diff --git a/nano/node/bootstrap/bootstrap_server.cpp b/nano/node/bootstrap/bootstrap_server.cpp index ae9e5f4bef..10d8d718ab 100644 --- a/nano/node/bootstrap/bootstrap_server.cpp +++ b/nano/node/bootstrap/bootstrap_server.cpp @@ -679,10 +679,24 @@ class request_response_visitor : public nano::message_visitor } void node_id_handshake (nano::node_id_handshake const & message_a) override { + // check for multiple handshake messages, there is no reason to receive more than one + if (message_a.query && connection->handshake_query_received) + { + if (connection->node->config.logging.network_node_id_handshake_logging ()) + { + connection->node->logger.try_log (boost::str (boost::format ("Detected multiple node_id_handshake query from %1%") % connection->remote_endpoint)); + } + connection->stop (); + return; + } + + connection->handshake_query_received = true; + if (connection->node->config.logging.network_node_id_handshake_logging ()) { connection->node->logger.try_log (boost::str (boost::format ("Received node_id_handshake message from %1%") % connection->remote_endpoint)); } + if (message_a.query) { 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))); diff --git a/nano/node/bootstrap/bootstrap_server.hpp b/nano/node/bootstrap/bootstrap_server.hpp index 0d055fe3fc..286139e061 100644 --- a/nano/node/bootstrap/bootstrap_server.hpp +++ b/nano/node/bootstrap/bootstrap_server.hpp @@ -70,6 +70,7 @@ class bootstrap_server final : public std::enable_shared_from_this> requests; std::atomic stopped{ false }; + std::atomic handshake_query_received{ false }; // 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{}; From 0bc1cf85e9450033bb88abb21cae820506f17987 Mon Sep 17 00:00:00 2001 From: clemahieu Date: Sun, 15 May 2022 00:56:50 +0100 Subject: [PATCH 16/34] Only allow 2 entries to have the same dependency. # Conflicts: # nano/secure/store/unchecked_store_partial.hpp --- nano/node/lmdb/unchecked_store.cpp | 4 ++++ nano/node/rocksdb/unchecked_store.cpp | 4 ++++ nano/secure/common.cpp | 2 +- 3 files changed, 9 insertions(+), 1 deletion(-) diff --git a/nano/node/lmdb/unchecked_store.cpp b/nano/node/lmdb/unchecked_store.cpp index 8be96e3831..4d13f63643 100644 --- a/nano/node/lmdb/unchecked_store.cpp +++ b/nano/node/lmdb/unchecked_store.cpp @@ -13,6 +13,10 @@ void nano::lmdb::unchecked_store::clear (nano::write_transaction const & transac void nano::lmdb::unchecked_store::put (nano::write_transaction const & transaction_a, nano::hash_or_account const & dependency, nano::unchecked_info const & info) { + if (get (transaction_a, dependency.as_block_hash ()).size () > 1) + { + return; + } auto status = store.put (transaction_a, tables::unchecked, nano::unchecked_key{ dependency, info.block->hash () }, info); store.release_assert_success (status); } diff --git a/nano/node/rocksdb/unchecked_store.cpp b/nano/node/rocksdb/unchecked_store.cpp index f884335243..fca03a3388 100644 --- a/nano/node/rocksdb/unchecked_store.cpp +++ b/nano/node/rocksdb/unchecked_store.cpp @@ -13,6 +13,10 @@ void nano::rocksdb::unchecked_store::clear (nano::write_transaction const & tran void nano::rocksdb::unchecked_store::put (nano::write_transaction const & transaction_a, nano::hash_or_account const & dependency, nano::unchecked_info const & info) { + if (get (transaction_a, dependency.as_block_hash ()).size () > 1) + { + return; + } auto status = store.put (transaction_a, tables::unchecked, nano::unchecked_key{ dependency, info.block->hash () }, info); store.release_assert_success (status); } diff --git a/nano/secure/common.cpp b/nano/secure/common.cpp index 89b8a2b941..865d9bc661 100644 --- a/nano/secure/common.cpp +++ b/nano/secure/common.cpp @@ -707,7 +707,7 @@ nano::unchecked_key::unchecked_key (nano::hash_or_account const & dependency) : } nano::unchecked_key::unchecked_key (nano::hash_or_account const & previous_a, nano::block_hash const & hash_a) : - previous (previous_a.hash), + previous (previous_a.as_block_hash ()), hash (hash_a) { } From 88a107cb9a1ab402fba8e42940d1cbce55757d8d Mon Sep 17 00:00:00 2001 From: clemahieu Date: Thu, 19 May 2022 14:34:09 +0100 Subject: [PATCH 17/34] Disable vote_processor flushing within the request loop which can block under heavy vote load. --- nano/node/active_transactions.cpp | 8 -------- 1 file changed, 8 deletions(-) diff --git a/nano/node/active_transactions.cpp b/nano/node/active_transactions.cpp index 9df65e523f..1004c259b4 100644 --- a/nano/node/active_transactions.cpp +++ b/nano/node/active_transactions.cpp @@ -575,14 +575,6 @@ void nano::active_transactions::request_loop () while (!stopped && !node.flags.disable_request_loop) { - // If many votes are queued, ensure at least the currently active ones finish processing - lock.unlock (); - if (node.vote_processor.half_full ()) - { - node.vote_processor.flush_active (); - } - lock.lock (); - auto const stamp_l = std::chrono::steady_clock::now (); request_confirm (lock); From 8567a2d4f441ac2568cd19005843bccd19948bcb Mon Sep 17 00:00:00 2001 From: clemahieu Date: Thu, 19 May 2022 14:34:33 +0100 Subject: [PATCH 18/34] Set inactive votes cache size to 0 as it causes excessive vote relaying. --- nano/node/active_transactions.cpp | 5 +++++ nano/node/nodeconfig.hpp | 2 +- 2 files changed, 6 insertions(+), 1 deletion(-) diff --git a/nano/node/active_transactions.cpp b/nano/node/active_transactions.cpp index 1004c259b4..9bc861bc61 100644 --- a/nano/node/active_transactions.cpp +++ b/nano/node/active_transactions.cpp @@ -1102,6 +1102,11 @@ std::size_t nano::active_transactions::inactive_votes_cache_size () void nano::active_transactions::add_inactive_votes_cache (nano::unique_lock & lock_a, nano::block_hash const & hash_a, nano::account const & representative_a, uint64_t const timestamp_a) { + if (node.flags.inactive_votes_cache_size == 0) + { + return; + } + // Check principal representative status if (node.ledger.weight (representative_a) > node.minimum_principal_weight ()) { diff --git a/nano/node/nodeconfig.hpp b/nano/node/nodeconfig.hpp index b3edf03cf2..31bb7334d6 100644 --- a/nano/node/nodeconfig.hpp +++ b/nano/node/nodeconfig.hpp @@ -148,7 +148,7 @@ class node_flags final 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 inactive_votes_cache_size{ 0 }; std::size_t vote_processor_capacity{ 144 * 1024 }; std::size_t bootstrap_interval{ 0 }; // For testing only }; From 86c63f825d7b7015691e7692902a3dfbed1dd054 Mon Sep 17 00:00:00 2001 From: Dimitrios Siganos Date: Mon, 23 May 2022 00:53:34 +0100 Subject: [PATCH 19/34] Bugfix: correctly check for magic bytes and network in message header The network bytes (magic bytes), the first 2 byts of the header, were not correctly checked. They were checked in the network class inbound function but that function is called for realtime messages after the handshake is completed. It is not called for bootstrap messages not handshake messages. Also the version checking was not done properly so I am doing it now properly immediately after the magic bytes tests. The checks are done at the following 3 places: * nano::bootstrap_server::receive_header_action * nano::transport::tcp_channels::start_tcp_receive_node_id * nano::message_parser::deserialize_buffer The last one is likely only used by UDP and test scripts that use UDP. So we should be able to remove the last one when we remove the UDP code. # Conflicts: # nano/core_test/network.cpp --- nano/core_test/network.cpp | 38 +++++++++++++++++++----- nano/node/bootstrap/bootstrap_server.cpp | 12 ++++++++ nano/node/common.cpp | 6 ++++ nano/node/network.cpp | 11 ++----- nano/node/transport/tcp.cpp | 13 +++++++- 5 files changed, 64 insertions(+), 16 deletions(-) diff --git a/nano/core_test/network.cpp b/nano/core_test/network.cpp index 70ea3f9dba..fd6229df3a 100644 --- a/nano/core_test/network.cpp +++ b/nano/core_test/network.cpp @@ -1272,17 +1272,41 @@ TEST (network, loopback_channel) } // Ensure the network filters messages with the incorrect magic number -TEST (network, filter) +TEST (network, filter_invalid_network_bytes) { - nano::system system{ 1 }; + nano::system system{ 2 }; auto & node1 = *system.nodes[0]; + auto & node2 = *system.nodes[1]; + + // find the comms channel that goes from node2 to node1 + auto channel = node2.network.find_channel (node1.network.endpoint ()); + ASSERT_NE (nullptr, channel); + + // send a keepalive, from node2 to node1, with the wrong network bytes 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, 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, node1)); - ASSERT_EQ (1, node1.stats.count (nano::stat::type::message, nano::stat::detail::invalid_network)); + channel->send (keepalive); + + ASSERT_TIMELY (5s, 1 == node1.stats.count (nano::stat::type::message, nano::stat::detail::invalid_network)); +} + +// Ensure the network filters messages with the incorrect minimum version +TEST (network, filter_invalid_version_using) +{ + nano::system system{ 2 }; + auto & node1 = *system.nodes[0]; + auto & node2 = *system.nodes[1]; + + // find the comms channel that goes from node2 to node1 + auto channel = node2.network.find_channel (node1.network.endpoint ()); + ASSERT_NE (nullptr, channel); + + // send a keepalive, from node2 to node1, with the wrong version_using + nano::keepalive keepalive{ nano::dev::network_params.network }; + const_cast (keepalive.header.version_using) = nano::dev::network_params.network.protocol_version_min - 1; + channel->send (keepalive); + + ASSERT_TIMELY (5s, 1 == node1.stats.count (nano::stat::type::message, nano::stat::detail::outdated_version)); } TEST (network, fill_keepalive_self) diff --git a/nano/node/bootstrap/bootstrap_server.cpp b/nano/node/bootstrap/bootstrap_server.cpp index 10d8d718ab..7148d2ca1a 100644 --- a/nano/node/bootstrap/bootstrap_server.cpp +++ b/nano/node/bootstrap/bootstrap_server.cpp @@ -204,6 +204,18 @@ void nano::bootstrap_server::receive_header_action (boost::system::error_code co nano::message_header header (error, type_stream); if (!error) { + if (header.network != node->network_params.network.current_network) + { + node->stats.inc (nano::stat::type::message, nano::stat::detail::invalid_network); + return; + } + + if (header.version_using < node->network_params.network.protocol_version_min) + { + node->stats.inc (nano::stat::type::message, nano::stat::detail::outdated_version); + return; + } + auto this_l (shared_from_this ()); switch (header.type) { diff --git a/nano/node/common.cpp b/nano/node/common.cpp index 5a3462eea9..0f531925fc 100644 --- a/nano/node/common.cpp +++ b/nano/node/common.cpp @@ -395,6 +395,12 @@ void nano::message_parser::deserialize_buffer (uint8_t const * buffer_a, std::si nano::message_header header (error, stream); if (!error) { + if (header.network != network.current_network) + { + status = parse_status::invalid_header; + return; + } + if (header.version_using < network.protocol_version_min) { status = parse_status::outdated_version; diff --git a/nano/node/network.cpp b/nano/node/network.cpp index e9fa2296ce..5885520a7f 100644 --- a/nano/node/network.cpp +++ b/nano/node/network.cpp @@ -15,14 +15,9 @@ nano::network::network (nano::node & node_a, uint16_t port_a) : 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); - } + debug_assert (message.header.network == node.network_params.network.current_network); + debug_assert (message.header.version_using >= node.network_params.network.protocol_version_min); + process_message (message, channel); } }, buffer_container (node_a.stats, nano::network::buffer_size, 4096), // 2Mb receive buffer resolver (node_a.io_ctx), diff --git a/nano/node/transport/tcp.cpp b/nano/node/transport/tcp.cpp index 92838ab679..f0623375e9 100644 --- a/nano/node/transport/tcp.cpp +++ b/nano/node/transport/tcp.cpp @@ -620,9 +620,10 @@ void nano::transport::tcp_channels::start_tcp_receive_node_id (std::shared_ptrdata (), size_a); nano::message_header header (error, stream); + // the header type should in principle be checked after checking the network bytes and the version numbers, I will not change it here since the benefits do not outweight the difficulties if (!error && header.type == nano::message_type::node_id_handshake) { - if (header.version_using >= node_l->network_params.network.protocol_version_min) + if (header.network == node_l->network_params.network.current_network && 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) @@ -693,6 +694,16 @@ void nano::transport::tcp_channels::start_tcp_receive_node_id (std::shared_ptrnetwork_params.network.current_network) + { + node_l->stats.inc (nano::stat::type::message, nano::stat::detail::invalid_network); + } + else + { + node_l->stats.inc (nano::stat::type::message, nano::stat::detail::outdated_version); + } + // Version of channel is not high enough, just abort. Don't fallback to udp, instead cleanup attempt cleanup_node_id_handshake_socket (endpoint_a); { From b9bd38e57591d28a5f7f87fb2ca6b674b53086ee Mon Sep 17 00:00:00 2001 From: Dimitrios Siganos Date: Fri, 27 May 2022 23:49:54 +0100 Subject: [PATCH 20/34] Remove a debug assert that crashes the node on receipt of zero node ID --- nano/node/transport/tcp.hpp | 1 - 1 file changed, 1 deletion(-) diff --git a/nano/node/transport/tcp.hpp b/nano/node/transport/tcp.hpp index aff3104d1c..1183e08f3d 100644 --- a/nano/node/transport/tcp.hpp +++ b/nano/node/transport/tcp.hpp @@ -183,7 +183,6 @@ namespace transport nano::account node_id () const { auto node_id (channel->get_node_id ()); - debug_assert (!node_id.is_zero ()); return node_id; } uint8_t network_version () const From b0b425090c88e19b305f2c8d4486494556faa431 Mon Sep 17 00:00:00 2001 From: Thiago Silva <82097354+thsfs@users.noreply.github.com> Date: Fri, 27 May 2022 20:18:53 -0300 Subject: [PATCH 21/34] Improves the vote processor class and limits its flush() (#142) - Limit the vote_processor::flush_active() - The is_active var became useless, also moved the lock position - Move the condition.notify_all() up - Improve function flush documentation - Test normal behavior is getting more votes than processing - Also updated the invalid_signature test to ASSERT_TIMELY since it should wait for a flush to happen. - Also removed the lock for reading total_processed atomic variable - Explicitly check for timeout in unit test vote_processor.overflow - Vote processor: clear votes and notify condition variable on thread exit In theory the vote processor can be stopped and have votes left in its queue which would just be strange and a potential source of problems. Also, a final kick of the condition variable is needed on thread exit and after vote clearing. - Check for confirm req loop blocking too long on vote process flush This has been a problem in the past and it is always tricky to do flush operations, so it is prudent to add a check for timeout here and display a warning in release and throw an assert in debug builds. - Use std::memory_order_relaxed in vote processor::flush for total_processed There is no need to take a memory barrier when reading the atomic total_processed, so use relaxed memory order. Co-Authored-By: Dimitrios Siganos Co-authored-by: Dimitrios Siganos # Conflicts: # nano/core_test/vote_processor.cpp --- nano/core_test/vote_processor.cpp | 65 ++++++++++++++++++++++++++++++- nano/node/active_transactions.cpp | 10 +++++ nano/node/vote_processor.cpp | 36 ++++++++--------- nano/node/vote_processor.hpp | 7 ++-- 4 files changed, 92 insertions(+), 26 deletions(-) diff --git a/nano/core_test/vote_processor.cpp b/nano/core_test/vote_processor.cpp index 52b4078935..9927ad339b 100644 --- a/nano/core_test/vote_processor.cpp +++ b/nano/core_test/vote_processor.cpp @@ -57,6 +57,63 @@ TEST (vote_processor, flush) ASSERT_TRUE (node.vote_processor.empty ()); } +// Tests the normal behavior is more votes getting into the vote_processor than getting processed, +// so the producer always wins. Also exercises the flush operation, so it must never deadlock. +TEST (vote_processor, producer_consumer) +{ + nano::system system (1); + auto & node (*system.nodes[0]); + auto channel (std::make_shared (node, node)); + + unsigned number_of_votes{ 25'000 }; + unsigned consumer_wins{ 0 }; + unsigned producer_wins{ 0 }; + + auto producer = [&node, &channel, &number_of_votes] () -> void { + for (unsigned i = 0; i < number_of_votes; ++i) + { + 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); + } + }; + + auto consumer = [&node, &number_of_votes] () -> void { + while (node.vote_processor.total_processed.load () < number_of_votes) + { + if (node.vote_processor.size () >= number_of_votes / 100) + { + node.vote_processor.flush (); + } + } + }; + + auto monitor = [&node, &number_of_votes, &producer_wins, &consumer_wins] () -> void { + while (node.vote_processor.total_processed.load () < number_of_votes) + { + std::this_thread::sleep_for (std::chrono::milliseconds (50)); + if (node.vote_processor.empty ()) + { + ++consumer_wins; + } + else + { + ++producer_wins; + } + } + }; + + std::thread producer_thread{ producer }; + std::thread consumer_thread{ consumer }; + std::thread monitor_thread{ monitor }; + + ASSERT_TIMELY (10s, node.vote_processor.total_processed.load () >= number_of_votes); + producer_thread.join (); + consumer_thread.join (); + monitor_thread.join (); + + ASSERT_TRUE (producer_wins > consumer_wins); +} + TEST (vote_processor, invalid_signature) { nano::system system{ 1 }; @@ -73,10 +130,10 @@ TEST (vote_processor, invalid_signature) ASSERT_EQ (1, election->votes ().size ()); node.vote_processor.vote (vote_invalid, channel); node.vote_processor.flush (); - ASSERT_EQ (1, election->votes ().size ()); + ASSERT_TIMELY (3s, 1 == election->votes ().size ()); node.vote_processor.vote (vote, channel); node.vote_processor.flush (); - ASSERT_EQ (2, election->votes ().size ()); + ASSERT_TIMELY (3s, 2 == election->votes ().size ()); } TEST (vote_processor, no_capacity) @@ -100,6 +157,7 @@ TEST (vote_processor, overflow) nano::keypair key; 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, node)); + auto start_time = std::chrono::system_clock::now (); // No way to lock the processor, but queueing votes in quick succession must result in overflow size_t not_processed{ 0 }; @@ -114,6 +172,9 @@ TEST (vote_processor, overflow) ASSERT_GT (not_processed, 0); ASSERT_LT (not_processed, total); ASSERT_EQ (not_processed, node.stats.count (nano::stat::type::vote, nano::stat::detail::vote_overflow)); + + // check that it did not timeout + ASSERT_LT (std::chrono::system_clock::now () - start_time, 10s); } namespace nano diff --git a/nano/node/active_transactions.cpp b/nano/node/active_transactions.cpp index 9bc861bc61..c5ef5280f4 100644 --- a/nano/node/active_transactions.cpp +++ b/nano/node/active_transactions.cpp @@ -575,9 +575,19 @@ void nano::active_transactions::request_loop () while (!stopped && !node.flags.disable_request_loop) { + // If many votes are queued, ensure at least the currently active ones finish processing + lock.unlock (); + condition.notify_all (); + if (node.vote_processor.half_full ()) + { + node.vote_processor.flush (); + } + lock.lock (); + auto const stamp_l = std::chrono::steady_clock::now (); request_confirm (lock); + debug_assert (lock.owns_lock ()); if (!stopped) { diff --git a/nano/node/vote_processor.cpp b/nano/node/vote_processor.cpp index a85025643f..7d92da6334 100644 --- a/nano/node/vote_processor.cpp +++ b/nano/node/vote_processor.cpp @@ -15,6 +15,9 @@ #include +#include +using namespace std::chrono_literals; + nano::vote_processor::vote_processor (nano::signature_checker & checker_a, nano::active_transactions & active_a, nano::node_observers & observers_a, nano::stat & stats_a, nano::node_config & config_a, nano::node_flags & flags_a, nano::logger_mt & logger_a, nano::online_reps & online_reps_a, nano::rep_crawler & rep_crawler_a, nano::ledger & ledger_a, nano::network_params & network_params_a) : checker (checker_a), active (active_a), @@ -29,10 +32,12 @@ nano::vote_processor::vote_processor (nano::signature_checker & checker_a, nano: max_votes (flags_a.vote_processor_capacity), started (false), stopped (false), - is_active (false), thread ([this] () { nano::thread_role::set (nano::thread_role::name::vote_processing); process_loop (); + nano::unique_lock lock (mutex); + votes.clear (); + condition.notify_all (); }) { nano::unique_lock lock (mutex); @@ -57,6 +62,8 @@ void nano::vote_processor::process_loop () { decltype (votes) votes_l; votes_l.swap (votes); + lock.unlock (); + condition.notify_all (); log_this_iteration = false; if (config.logging.network_logging () && votes_l.size () > 50) @@ -68,21 +75,14 @@ void nano::vote_processor::process_loop () log_this_iteration = true; elapsed.restart (); } - is_active = true; - lock.unlock (); verify_votes (votes_l); - lock.lock (); - is_active = false; - - lock.unlock (); - condition.notify_all (); total_processed += votes_l.size (); - lock.lock (); if (log_this_iteration && elapsed.stop () > std::chrono::milliseconds (100)) { logger.try_log (boost::str (boost::format ("Processed %1% votes in %2% milliseconds (rate of %3% votes per second)") % votes_l.size () % elapsed.value ().count () % ((votes_l.size () * 1000ULL) / elapsed.value ().count ()))); } + lock.lock (); } else { @@ -219,18 +219,14 @@ void nano::vote_processor::stop () void nano::vote_processor::flush () { nano::unique_lock lock (mutex); - while (is_active || !votes.empty ()) - { - condition.wait (lock); - } -} - -void nano::vote_processor::flush_active () -{ - nano::unique_lock lock (mutex); - while (is_active) + auto const cutoff = total_processed.load (std::memory_order_relaxed) + votes.size (); + bool success = condition.wait_for (lock, 60s, [this, &cutoff] () { + return stopped || votes.empty () || total_processed.load (std::memory_order_relaxed) >= cutoff; + }); + if (!success) { - condition.wait (lock); + logger.always_log ("WARNING: vote_processor::flush timeout while waiting for flush"); + debug_assert (false && "vote_processor::flush timeout while waiting for flush"); } } diff --git a/nano/node/vote_processor.hpp b/nano/node/vote_processor.hpp index d1175363f9..20b550de8a 100644 --- a/nano/node/vote_processor.hpp +++ b/nano/node/vote_processor.hpp @@ -41,9 +41,9 @@ class vote_processor final /** Note: node.active.mutex lock is required */ nano::vote_code vote_blocking (std::shared_ptr const &, std::shared_ptr const &, bool = false); void verify_votes (std::deque, std::shared_ptr>> const &); + /** Function blocks until either the current queue size (a established flush boundary as it'll continue to increase) + * is processed or the queue is empty (end condition or cutoff's guard, as it is positioned ahead) */ void flush (); - /** Block until the currently active processing cycle finishes */ - void flush_active (); std::size_t size (); bool empty (); bool half_full (); @@ -64,7 +64,7 @@ class vote_processor final nano::rep_crawler & rep_crawler; nano::ledger & ledger; nano::network_params & network_params; - std::size_t max_votes; + std::size_t const max_votes; std::deque, std::shared_ptr>> votes; /** Representatives levels for random early detection */ std::unordered_set representatives_1; @@ -74,7 +74,6 @@ class vote_processor final nano::mutex mutex{ mutex_identifier (mutexes::vote_processor) }; bool started; bool stopped; - bool is_active; std::thread thread; friend std::unique_ptr collect_container_info (vote_processor & vote_processor, std::string const & name); From d7a5828b8bb1302502fded867680d182290471dd Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20W=C3=B3jcik?= <3044353+fikumikudev@users.noreply.github.com> Date: Thu, 9 Jun 2022 15:10:51 +0200 Subject: [PATCH 22/34] Vote hinting reenable (#152) * Remove unused `previous_balance` field and unnecessary ledger lookup * Add a new hinted election behavior * Adjust time to live for hinted elections * Reenable inactive vote cache with more aggressive threshold (big thanks to @trashman for tuning those parameters) * Fix `inactive_votes_cache_election_start` unit test * Add test for vote hinting election limit * Add config option for vote hinting limit * Use a counter for number of active hinted elections * Add more election stats * Revert "Add config option for vote hinting limit" This reverts commit d5a9fd5d350e0ad3e7e927348b173b3e59516e2e. * Use ratio as hinted election limit instead of absolute value * Naming change to `active_elections_hinted_limit_percentage` * Vote hinting cleanup # Conflicts: # nano/core_test/active_transactions.cpp # nano/lib/stats.cpp # nano/lib/stats.hpp # nano/node/election.cpp # nano/node/election_scheduler.cpp --- nano/core_test/active_transactions.cpp | 173 ++++++++++++++++++++++++- nano/lib/stats.cpp | 14 ++ nano/lib/stats.hpp | 5 + nano/node/active_transactions.cpp | 68 +++++++--- nano/node/active_transactions.hpp | 9 +- nano/node/election.cpp | 18 ++- nano/node/election.hpp | 4 +- nano/node/election_scheduler.cpp | 4 +- nano/node/nodeconfig.hpp | 5 +- 9 files changed, 270 insertions(+), 30 deletions(-) diff --git a/nano/core_test/active_transactions.cpp b/nano/core_test/active_transactions.cpp index c58c239b64..d2d57ce5ec 100644 --- a/nano/core_test/active_transactions.cpp +++ b/nano/core_test/active_transactions.cpp @@ -414,17 +414,19 @@ TEST (active_transactions, inactive_votes_cache_election_start) nano::keypair key1, key2; nano::send_block_builder send_block_builder; nano::state_block_builder state_block_builder; + // Enough weight to trigger election hinting but not enough to confirm block on its own + auto amount = ((node.online_reps.trended () / 100) * node.config.election_hint_weight_percent) / 2 + 1000 * nano::Gxrb_ratio; auto send1 = send_block_builder.make_block () .previous (latest) .destination (key1.pub) - .balance (nano::dev::constants.genesis_amount - 5000 * nano::Gxrb_ratio) + .balance (nano::dev::constants.genesis_amount - amount) .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::dev::constants.genesis_amount - 10000 * nano::Gxrb_ratio) + .balance (nano::dev::constants.genesis_amount - 2 * amount) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) .build_shared (); @@ -432,7 +434,7 @@ TEST (active_transactions, inactive_votes_cache_election_start) .account (key1.pub) .previous (0) .representative (key1.pub) - .balance (5000 * nano::Gxrb_ratio) + .balance (amount) .link (send1->hash ()) .sign (key1.prv, key1.pub) .work (*system.work.generate (key1.pub)) @@ -441,7 +443,7 @@ TEST (active_transactions, inactive_votes_cache_election_start) .account (key2.pub) .previous (0) .representative (key2.pub) - .balance (5000 * nano::Gxrb_ratio) + .balance (amount) .link (send2->hash ()) .sign (key2.prv, key2.pub) .work (*system.work.generate (key2.pub)) @@ -1512,3 +1514,166 @@ TEST (active_transactions, fifo) // Ensure the surviving transaction is the least recently inserted ASSERT_TIMELY (1s, node.active.election (receive2->qualified_root ()) != nullptr); } + +// Ensures we limit the number of vote hinted elections in AEC +TEST (active_transactions, limit_vote_hinted_elections) +{ + nano::system system; + nano::node_config config{ nano::get_available_port (), system.logging }; + config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; + config.active_elections_size = 10; + config.active_elections_hinted_limit_percentage = 10; // Should give us a limit of 1 hinted election + auto & node = *system.add_node (config); + + // Setup representatives + nano::keypair rep1, rep2; + { + 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; + // Enough weight to trigger election hinting but not enough to confirm block on its own + auto amount = ((node.online_reps.trended () / 100) * node.config.election_hint_weight_percent) / 2 + 1000 * nano::Gxrb_ratio; + auto send1 = send_block_builder.make_block () + .previous (latest) + .destination (key1.pub) + .balance (nano::dev::constants.genesis_amount - amount) + .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::dev::constants.genesis_amount - 2 * amount) + .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 () + .account (key1.pub) + .previous (0) + .representative (key1.pub) + .balance (amount) + .link (send1->hash ()) + .sign (key1.prv, key1.pub) + .work (*system.work.generate (key1.pub)) + .build_shared (); + auto open2 = state_block_builder.make_block () + .account (key2.pub) + .previous (0) + .representative (key2.pub) + .balance (amount) + .link (send2->hash ()) + .sign (key2.prv, key2.pub) + .work (*system.work.generate (key2.pub)) + .build_shared (); + ASSERT_EQ (nano::process_result::progress, node.process (*send1).code); + ASSERT_EQ (nano::process_result::progress, node.process (*send2).code); + ASSERT_EQ (nano::process_result::progress, node.process (*open1).code); + ASSERT_EQ (nano::process_result::progress, node.process (*open2).code); + nano::blocks_confirm (node, { send1, send2, open1, open2 }, true); + ASSERT_TIMELY (1s, node.block_confirmed (send1->hash ())); + ASSERT_TIMELY (1s, node.block_confirmed (send2->hash ())); + ASSERT_TIMELY (1s, node.block_confirmed (open1->hash ())); + ASSERT_TIMELY (1s, node.block_confirmed (open2->hash ())); + ASSERT_TIMELY (1s, node.active.empty ()); + rep1 = key1; + rep2 = key2; + } + // Test vote hinting behavior + { + auto latest_balance = node.balance (nano::dev::genesis_key.pub); + auto latest = node.latest (nano::dev::genesis_key.pub); + nano::keypair key0, key1; + 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 (latest) + .representative (nano::dev::genesis_key.pub) + .link (key0.pub) + .balance (latest_balance - 1) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (latest)) + .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) + .previous (send0->hash ()) + .representative (nano::dev::genesis_key.pub) + .link (key1.pub) + .balance (latest_balance - 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); + nano::blocks_confirm (node, { send1 }, true); + ASSERT_TIMELY (1s, node.block_confirmed (send1->hash ())); + ASSERT_TIMELY (1s, node.active.empty ()); + + auto receive0 = builder.make_block () + .account (key0.pub) + .previous (0) + .representative (nano::dev::genesis_key.pub) + .link (send0->hash ()) + .balance (1) + .sign (key0.prv, key0.pub) + .work (*system.work.generate (key0.pub)) + .build_shared (); + ASSERT_EQ (nano::process_result::progress, node.process (*receive0).code); + auto receive1 = builder.make_block () + .account (key1.pub) + .previous (0) + .representative (nano::dev::genesis_key.pub) + .link (send1->hash ()) + .balance (1) + .sign (key1.prv, key1.pub) + .work (*system.work.generate (key1.pub)) + .build_shared (); + ASSERT_EQ (nano::process_result::progress, node.process (*receive1).code); + ASSERT_TRUE (node.active.empty ()); + ASSERT_EQ (7, node.ledger.cache.cemented_count); + + // Inactive vote + auto vote1 (std::make_shared (rep1.pub, rep1.prv, 0, 0, std::vector{ receive0->hash (), receive1->hash () })); + node.vote_processor.vote (vote1, std::make_shared (node, node)); + ASSERT_TIMELY (1s, node.active.inactive_votes_cache_size () == 2); + ASSERT_TRUE (node.active.empty ()); + ASSERT_EQ (7, node.ledger.cache.cemented_count); + + // This vote should trigger election hinting for first receive block + auto vote2 (std::make_shared (rep2.pub, rep2.prv, 0, 0, std::vector{ receive0->hash () })); + node.vote_processor.vote (vote2, std::make_shared (node, node)); + ASSERT_TIMELY (1s, 1 == node.active.size ()); + // Ensure first transaction becomes active + ASSERT_TIMELY (1s, node.active.election (receive0->qualified_root ()) != nullptr); + + // This vote should trigger election hinting but not become active due to limit of active hinted elections + auto vote3 (std::make_shared (rep2.pub, rep2.prv, 0, 0, std::vector{ receive1->hash () })); + node.vote_processor.vote (vote3, std::make_shared (node, node)); + ASSERT_TIMELY (1s, node.stats.count (nano::stat::type::election, nano::stat::detail::election_hinted_overflow) == 1); + ASSERT_TIMELY (1s, 1 == node.active.size ()); + // Ensure second transaction does not become active + ASSERT_TIMELY (1s, node.active.election (receive1->qualified_root ()) == nullptr); + + // This final vote should confirm the first receive block + auto vote4 = (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_max, nano::vote::duration_max, std::vector{ receive0->hash () })); + node.vote_processor.vote (vote4, std::make_shared (node, node)); + ASSERT_TIMELY (1s, node.active.empty ()); + ASSERT_EQ (8, node.ledger.cache.cemented_count); + ASSERT_TIMELY (1s, node.active.inactive_votes_cache_size () == 1); + + // Now it should be possible to vote hint second block + auto vote5 = (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, 0, 0, std::vector{ receive1->hash () })); + node.vote_processor.vote (vote5, std::make_shared (node, node)); + ASSERT_TIMELY (1s, node.stats.count (nano::stat::type::election, nano::stat::detail::election_hinted_overflow) == 1); + ASSERT_TIMELY (1s, 1 == node.active.size ()); + ASSERT_EQ (8, node.ledger.cache.cemented_count); + ASSERT_TIMELY (1s, node.active.inactive_votes_cache_size () == 1); + + // Ensure there was no overflow + ASSERT_EQ (0, node.stats.count (nano::stat::type::election, nano::stat::detail::election_drop_overflow)); + } +} diff --git a/nano/lib/stats.cpp b/nano/lib/stats.cpp index db30ffbd92..8a89f7d8d2 100644 --- a/nano/lib/stats.cpp +++ b/nano/lib/stats.cpp @@ -708,6 +708,9 @@ std::string nano::stat::detail_to_string (stat::detail detail) case nano::stat::detail::election_start: res = "election_start"; break; + case nano::stat::detail::election_confirmed_all: + res = "election_confirmed_all"; + break; case nano::stat::detail::election_block_conflict: res = "election_block_conflict"; break; @@ -731,6 +734,17 @@ std::string nano::stat::detail_to_string (stat::detail detail) break; case nano::stat::detail::election_not_confirmed: res = "election_not_confirmed"; + case nano::stat::detail::election_hinted_overflow: + res = "election_hinted_overflow"; + break; + case nano::stat::detail::election_hinted_started: + res = "election_hinted_started"; + break; + case nano::stat::detail::election_hinted_confirmed: + res = "election_hinted_confirmed"; + break; + case nano::stat::detail::election_hinted_drop: + res = "election_hinted_drop"; break; case nano::stat::detail::blocking: res = "blocking"; diff --git a/nano/lib/stats.hpp b/nano/lib/stats.hpp index a8b0b1bd7e..375e03934c 100644 --- a/nano/lib/stats.hpp +++ b/nano/lib/stats.hpp @@ -318,6 +318,7 @@ class stat final late_block, late_block_seconds, election_start, + election_confirmed_all, election_block_conflict, election_difficulty_update, election_drop_expired, @@ -326,6 +327,10 @@ class stat final election_restart, election_confirmed, election_not_confirmed, + election_hinted_overflow, + election_hinted_started, + election_hinted_confirmed, + election_hinted_drop, // udp blocking, diff --git a/nano/node/active_transactions.cpp b/nano/node/active_transactions.cpp index c5ef5280f4..a403dbcd55 100644 --- a/nano/node/active_transactions.cpp +++ b/nano/node/active_transactions.cpp @@ -63,7 +63,7 @@ bool nano::active_transactions::insert_election_from_frontiers_confirmation (std }; } - auto insert_result = insert_impl (lock, block_a, previous_balance_a, election_behavior_a, election_confirmation_cb); + auto insert_result = insert_impl (lock, block_a, election_behavior_a, election_confirmation_cb); inserted = insert_result.inserted; if (inserted) { @@ -350,9 +350,28 @@ void nano::active_transactions::request_confirm (nano::unique_lock void nano::active_transactions::cleanup_election (nano::unique_lock & lock_a, nano::election const & election) { + debug_assert (lock_a.owns_lock ()); + if (!election.confirmed ()) { node.stats.inc (nano::stat::type::election, nano::stat::detail::election_drop_all); + if (election.behavior == election_behavior::hinted) + { + node.stats.inc (nano::stat::type::election, nano::stat::detail::election_hinted_drop); + } + } + else + { + node.stats.inc (nano::stat::type::election, nano::stat::detail::election_confirmed_all); + if (election.behavior == election_behavior::hinted) + { + node.stats.inc (nano::stat::type::election, nano::stat::detail::election_hinted_confirmed); + } + } + + if (election.behavior == election_behavior::hinted) + { + --active_hinted_elections_count; } auto blocks_l = election.blocks (); @@ -796,7 +815,7 @@ void nano::active_transactions::stop () roots.clear (); } -nano::election_insertion_result nano::active_transactions::insert_impl (nano::unique_lock & lock_a, std::shared_ptr const & block_a, boost::optional const & previous_balance_a, nano::election_behavior election_behavior_a, std::function const &)> const & confirmation_action_a) +nano::election_insertion_result nano::active_transactions::insert_impl (nano::unique_lock & lock_a, std::shared_ptr const & block_a, nano::election_behavior election_behavior_a, std::function const &)> const & confirmation_action_a) { debug_assert (lock_a.owns_lock ()); debug_assert (block_a->has_sideband ()); @@ -812,24 +831,19 @@ nano::election_insertion_result nano::active_transactions::insert_impl (nano::un result.inserted = true; auto hash (block_a->hash ()); auto epoch (block_a->sideband ().details.epoch); - nano::uint128_t previous_balance (previous_balance_a.value_or (0)); - debug_assert (!(previous_balance_a.value_or (0) > 0 && block_a->previous ().is_zero ())); - 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 ())) - { - previous_balance = node.ledger.balance (transaction, block_a->previous ()); - } - } result.election = nano::make_shared ( node, block_a, confirmation_action_a, [&node = node] (auto const & rep_a) { // Representative is defined as online if replying to live votes or rep_crawler queries node.online_reps.observe (rep_a); }, election_behavior_a); - roots.get ().emplace (nano::active_transactions::conflict_info{ root, result.election, epoch, previous_balance }); + roots.get ().emplace (nano::active_transactions::conflict_info{ root, result.election, epoch, election_behavior_a }); blocks.emplace (hash, result.election); + // Increase hinted election counter while still holding lock + if (election_behavior_a == election_behavior::hinted) + { + active_hinted_elections_count++; + } auto const cache = find_inactive_votes_cache_impl (hash); lock_a.unlock (); result.election->insert_inactive_votes_cache (cache); @@ -857,6 +871,26 @@ nano::election_insertion_result nano::active_transactions::insert_impl (nano::un return result; } +nano::election_insertion_result nano::active_transactions::insert_hinted (nano::unique_lock & lock_a, std::shared_ptr const & block_a) +{ + debug_assert (lock_a.owns_lock ()); + + const std::size_t limit = node.config.active_elections_hinted_limit_percentage * node.config.active_elections_size / 100; + if (active_hinted_elections_count >= limit) + { + // Reached maximum number of hinted elections, drop new ones + node.stats.inc (nano::stat::type::election, nano::stat::detail::election_hinted_overflow); + return {}; + } + + auto result = insert_impl (lock_a, block_a, nano::election_behavior::hinted); + if (result.inserted) + { + node.stats.inc (nano::stat::type::election, nano::stat::detail::election_hinted_started); + } + return result; +} + // Validate a vote and apply it to the current election if one exists nano::vote_code nano::active_transactions::vote (std::shared_ptr const & vote_a) { @@ -1189,7 +1223,7 @@ void nano::active_transactions::trigger_inactive_votes_cache_election (std::shar auto const status = find_inactive_votes_cache_impl (block_a->hash ()).status; if (status.election_started) { - insert_impl (lock, block_a); + insert_hinted (lock, block_a); } } @@ -1271,7 +1305,11 @@ nano::inactive_cache_status nano::active_transactions::inactive_votes_bootstrap_ 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); + auto result = insert_hinted (lock_a, block); + if (!result.inserted && result.election == nullptr) + { + status.election_started = false; + } } else if (!block && status.bootstrap_started && !previously_a.bootstrap_started && (!node.ledger.pruning || !node.store.pruned.exists (transaction, hash_a))) { diff --git a/nano/node/active_transactions.hpp b/nano/node/active_transactions.hpp index 7eb6dcef61..47b36d8217 100644 --- a/nano/node/active_transactions.hpp +++ b/nano/node/active_transactions.hpp @@ -89,7 +89,7 @@ class active_transactions final nano::qualified_root root; std::shared_ptr election; nano::epoch epoch; - nano::uint128_t previous_balance; + nano::election_behavior election_behavior; // Used to prioritize portion of AEC for vote hinting }; friend class nano::election; @@ -112,7 +112,8 @@ class active_transactions final mi::indexed_by< mi::random_access>, mi::hashed_unique, - mi::member>>>; + mi::member> + >>; // clang-format on ordered_roots roots; using roots_iterator = active_transactions::ordered_roots::index_iterator::type; @@ -190,8 +191,9 @@ class active_transactions final // Call action with confirmed block, may be different than what we started with // clang-format off - nano::election_insertion_result insert_impl (nano::unique_lock &, std::shared_ptr const&, boost::optional const & = boost::none, nano::election_behavior = nano::election_behavior::normal, std::functionconst&)> const & = nullptr); + nano::election_insertion_result insert_impl (nano::unique_lock &, std::shared_ptr const&, nano::election_behavior = nano::election_behavior::normal, std::functionconst&)> const & = nullptr); // clang-format on + nano::election_insertion_result insert_hinted (nano::unique_lock & lock_a, std::shared_ptr const & block_a); void request_loop (); void request_confirm (nano::unique_lock &); void erase (nano::qualified_root const &); @@ -237,6 +239,7 @@ class active_transactions final expired_optimistic_election_infos; // clang-format on std::atomic expired_optimistic_election_infos_size{ 0 }; + int active_hinted_elections_count{ 0 }; // Frontiers confirmation nano::frontiers_confirmation_info get_frontiers_confirmation_info (); diff --git a/nano/node/election.cpp b/nano/node/election.cpp index 0ec923e166..8dfb798d3b 100644 --- a/nano/node/election.cpp +++ b/nano/node/election.cpp @@ -193,9 +193,8 @@ bool nano::election::transition_time (nano::confirmation_solicitor & solicitor_a debug_assert (false); break; } - 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) + + if (!confirmed () && time_to_live () < std::chrono::steady_clock::now () - election_start) { nano::lock_guard guard (mutex); // It is possible the election confirmed while acquiring the mutex @@ -213,6 +212,19 @@ bool nano::election::transition_time (nano::confirmation_solicitor & solicitor_a return result; } +std::chrono::milliseconds nano::election::time_to_live () +{ + switch (behavior) + { + case election_behavior::normal: + return std::chrono::milliseconds (5 * 60 * 1000); + case election_behavior::optimistic: + return std::chrono::milliseconds (node.network_params.network.is_dev_network () ? 500 : 60 * 1000); + case election_behavior::hinted: + return std::chrono::milliseconds (30 * 1000); + } +} + bool nano::election::have_quorum (nano::tally_t const & tally_a) const { auto i (tally_a.begin ()); diff --git a/nano/node/election.hpp b/nano/node/election.hpp index a1358300b7..e450d5c275 100644 --- a/nano/node/election.hpp +++ b/nano/node/election.hpp @@ -43,7 +43,8 @@ class election_vote_result final enum class election_behavior { normal, - optimistic + optimistic, + hinted }; struct election_extended_status final { @@ -127,6 +128,7 @@ class election final : public std::enable_shared_from_this void remove_votes (nano::block_hash const &); void remove_block (nano::block_hash const &); bool replace_by_weight (nano::unique_lock & lock_a, nano::block_hash const &); + std::chrono::milliseconds time_to_live (); private: std::unordered_map> last_blocks; diff --git a/nano/node/election_scheduler.cpp b/nano/node/election_scheduler.cpp index 5d4194dc04..adcaa17509 100644 --- a/nano/node/election_scheduler.cpp +++ b/nano/node/election_scheduler.cpp @@ -125,7 +125,7 @@ void nano::election_scheduler::run () 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); + node.active.insert_impl (lock2, block, election_behavior, confirmation_action); } else if (priority_queue_predicate ()) { @@ -158,4 +158,4 @@ std::unique_ptr nano::election_scheduler::collec composite->add_component (std::make_unique (container_info{ "manual_queue", manual_queue.size (), sizeof (decltype (manual_queue)::value_type) })); composite->add_component (priority.collect_container_info ("priority")); return composite; -} \ No newline at end of file +} diff --git a/nano/node/nodeconfig.hpp b/nano/node/nodeconfig.hpp index 31bb7334d6..ea7bb9b5e0 100644 --- a/nano/node/nodeconfig.hpp +++ b/nano/node/nodeconfig.hpp @@ -54,7 +54,7 @@ class node_config std::chrono::milliseconds vote_generator_delay{ std::chrono::milliseconds (100) }; unsigned vote_generator_threshold{ 3 }; nano::amount online_weight_minimum{ 60000 * nano::Gxrb_ratio }; - unsigned election_hint_weight_percent{ 10 }; + unsigned election_hint_weight_percent{ 50 }; unsigned password_fanout{ 1024 }; unsigned io_threads{ std::max (4, std::thread::hardware_concurrency ()) }; unsigned network_threads{ std::max (4, std::thread::hardware_concurrency ()) }; @@ -83,6 +83,7 @@ class node_config 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 }; std::size_t active_elections_size{ 5000 }; + std::size_t active_elections_hinted_limit_percentage{ 20 }; // Limit of hinted elections as percentage of active_elections_size /** Default maximum incoming TCP connections, including realtime network & bootstrap */ unsigned tcp_incoming_connections_max{ 2048 }; bool use_memory_pools{ true }; @@ -148,7 +149,7 @@ class node_flags final 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{ 0 }; + std::size_t inactive_votes_cache_size{ 1024 * 128 }; std::size_t vote_processor_capacity{ 144 * 1024 }; std::size_t bootstrap_interval{ 0 }; // For testing only }; From d22ac4c8187522c62447ef56fcce54e5bf7a1ff0 Mon Sep 17 00:00:00 2001 From: clemahieu Date: Wed, 8 Jun 2022 12:40:59 +0100 Subject: [PATCH 23/34] Removing unchecked.for_each_par as it's effectively unused. This disables migrating of unchecked table from lmdb to rocksdb, however, this upgrade really isn't needed. # Conflicts: # nano/secure/store.hpp # nano/secure/store/unchecked_store_partial.hpp --- nano/node/lmdb/unchecked_store.cpp | 11 ----------- nano/node/lmdb/unchecked_store.hpp | 1 - nano/node/rocksdb/unchecked_store.cpp | 11 ----------- nano/node/rocksdb/unchecked_store.hpp | 1 - nano/secure/store.hpp | 1 - 5 files changed, 25 deletions(-) diff --git a/nano/node/lmdb/unchecked_store.cpp b/nano/node/lmdb/unchecked_store.cpp index 4d13f63643..3020bda57d 100644 --- a/nano/node/lmdb/unchecked_store.cpp +++ b/nano/node/lmdb/unchecked_store.cpp @@ -54,14 +54,3 @@ size_t nano::lmdb::unchecked_store::count (nano::transaction const & transaction { return store.count (transaction_a, tables::unchecked); } - -void nano::lmdb::unchecked_store::for_each_par (std::function, nano::store_iterator)> const & action_a) const -{ - 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->lower_bound (transaction, key_start), !is_last ? this->lower_bound (transaction, key_end) : this->end ()); - }); -} diff --git a/nano/node/lmdb/unchecked_store.hpp b/nano/node/lmdb/unchecked_store.hpp index 5cb40acb64..3f6b9029a1 100644 --- a/nano/node/lmdb/unchecked_store.hpp +++ b/nano/node/lmdb/unchecked_store.hpp @@ -25,7 +25,6 @@ namespace lmdb nano::store_iterator begin (nano::transaction const & transaction_a) const override; nano::store_iterator lower_bound (nano::transaction const & transaction_a, nano::unchecked_key const & key_a) const override; size_t count (nano::transaction const & transaction_a) override; - void for_each_par (std::function, nano::store_iterator)> const & action_a) const override; /** * Unchecked bootstrap blocks info. diff --git a/nano/node/rocksdb/unchecked_store.cpp b/nano/node/rocksdb/unchecked_store.cpp index fca03a3388..50e5c739b0 100644 --- a/nano/node/rocksdb/unchecked_store.cpp +++ b/nano/node/rocksdb/unchecked_store.cpp @@ -54,14 +54,3 @@ size_t nano::rocksdb::unchecked_store::count (nano::transaction const & transact { return store.count (transaction_a, tables::unchecked); } - -void nano::rocksdb::unchecked_store::for_each_par (std::function, nano::store_iterator)> const & action_a) const -{ - 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->lower_bound (transaction, key_start), !is_last ? this->lower_bound (transaction, key_end) : this->end ()); - }); -} diff --git a/nano/node/rocksdb/unchecked_store.hpp b/nano/node/rocksdb/unchecked_store.hpp index 7a75b796e0..35942c551c 100644 --- a/nano/node/rocksdb/unchecked_store.hpp +++ b/nano/node/rocksdb/unchecked_store.hpp @@ -23,7 +23,6 @@ namespace rocksdb nano::store_iterator begin (nano::transaction const & transaction_a) const override; nano::store_iterator lower_bound (nano::transaction const & transaction_a, nano::unchecked_key const & key_a) const override; size_t count (nano::transaction const & transaction_a) override; - void for_each_par (std::function, nano::store_iterator)> const & action_a) const override; }; } } diff --git a/nano/secure/store.hpp b/nano/secure/store.hpp index 84a89a7a7f..2b22aae571 100644 --- a/nano/secure/store.hpp +++ b/nano/secure/store.hpp @@ -763,7 +763,6 @@ class unchecked_store virtual iterator lower_bound (nano::transaction const &, nano::unchecked_key const &) const = 0; virtual iterator end () const = 0; virtual size_t count (nano::transaction const &) = 0; - virtual void for_each_par (std::function const & action_a) const = 0; }; /** From ce9e261cd71e491cda42afa2236b9fd31c7a4c3f Mon Sep 17 00:00:00 2001 From: clemahieu Date: Wed, 8 Jun 2022 13:34:40 +0100 Subject: [PATCH 24/34] Converting functions on unchecked_map that return iterators to instead use for_each with a functor to execute on each result. This prevents iteration details from being exposed externally. # Conflicts: # nano/core_test/block_store.cpp # nano/nano_node/entry.cpp # nano/node/json_handler.cpp # nano/node/lmdb/lmdb.cpp # nano/node/node.cpp # nano/secure/store.hpp # nano/secure/store/unchecked_store_partial.hpp --- nano/core_test/block_store.cpp | 12 +++++--- nano/core_test/unchecked_map.cpp | 10 +++--- nano/nano_node/entry.cpp | 7 ++--- nano/node/json_handler.cpp | 52 ++++++++++++-------------------- nano/node/node.cpp | 11 +++---- nano/node/unchecked_map.cpp | 18 +++++++++++ nano/node/unchecked_map.hpp | 13 +++++--- 7 files changed, 65 insertions(+), 58 deletions(-) diff --git a/nano/core_test/block_store.cpp b/nano/core_test/block_store.cpp index aad7a877c6..299be5a784 100644 --- a/nano/core_test/block_store.cpp +++ b/nano/core_test/block_store.cpp @@ -468,10 +468,9 @@ TEST (unchecked, multiple_get) auto count_unchecked_blocks_one_by_one = [&store, &unchecked] () { size_t count = 0; auto transaction = store->tx_begin_read (); - for (auto [i, end] = unchecked.full_range (transaction); i != end; ++i) - { + unchecked.for_each (transaction, [&count] (nano::unchecked_key const & key, nano::unchecked_info const & info) { ++count; - } + }); return count; }; @@ -545,8 +544,11 @@ TEST (block_store, empty_bootstrap) nano::unchecked_map unchecked{ *store, false }; ASSERT_TRUE (!store->init_error ()); auto transaction (store->tx_begin_read ()); - auto [begin, end] = unchecked.full_range (transaction); - ASSERT_EQ (end, begin); + size_t count = 0; + unchecked.for_each (transaction, [&count] (nano::unchecked_key const & key, nano::unchecked_info const & info) { + ++count; + }); + ASSERT_EQ (count, 0); } TEST (block_store, unchecked_begin_search) diff --git a/nano/core_test/unchecked_map.cpp b/nano/core_test/unchecked_map.cpp index 742cdc6e01..867954beb5 100644 --- a/nano/core_test/unchecked_map.cpp +++ b/nano/core_test/unchecked_map.cpp @@ -68,14 +68,14 @@ TEST (block_store, one_bootstrap) // Waits for the block1 to get saved in the database ASSERT_TIMELY (10s, check_block_is_listed (store->tx_begin_read (), block1->hash ())); auto transaction = store->tx_begin_read (); - auto [begin, end] = unchecked.full_range (transaction); - ASSERT_NE (end, begin); - auto hash1 = begin->first.key (); + std::vector dependencies; + unchecked.for_each (transaction, [&dependencies] (nano::unchecked_key const & key, nano::unchecked_info const & info) { + dependencies.push_back (key.key ()); + }); + auto hash1 = dependencies[0]; ASSERT_EQ (block1->hash (), hash1); auto blocks = unchecked.get (transaction, hash1); ASSERT_EQ (1, blocks.size ()); auto block2 = blocks[0].block; ASSERT_EQ (*block1, *block2); - ++begin; - ASSERT_EQ (end, begin); } diff --git a/nano/nano_node/entry.cpp b/nano/nano_node/entry.cpp index f1112c52e9..ed493c0f63 100644 --- a/nano/nano_node/entry.cpp +++ b/nano/nano_node/entry.cpp @@ -439,14 +439,13 @@ int main (int argc, char * const * argv) } // Check all unchecked keys for matching frontier hashes. Indicates an issue with process_batch algorithm - for (auto [i, n] = node->unchecked.full_range (transaction); i != n; ++i) - { - auto it = frontier_hashes.find (i->first.key ()); + node->store.unchecked.for_each (transaction, [&frontier_hashes] (nano::unchecked_key const & key, nano::unchecked_info const & info) { + auto it = frontier_hashes.find (key.key ()); if (it != frontier_hashes.cend ()) { std::cout << it->to_string () << "\n"; } - } + }); } else if (vm.count ("debug_account_count")) { diff --git a/nano/node/json_handler.cpp b/nano/node/json_handler.cpp index 8f23be98ac..b221c86b54 100644 --- a/nano/node/json_handler.cpp +++ b/nano/node/json_handler.cpp @@ -4126,9 +4126,8 @@ void nano::json_handler::unchecked () { boost::property_tree::ptree unchecked; auto transaction (node.store.tx_begin_read ()); - for (auto [i, n] = node.unchecked.full_range (transaction); i != n && unchecked.size () < count; ++i) - { - nano::unchecked_info const & info (i->second); + node.unchecked.for_each ( + transaction, [&unchecked, &json_block_l] (nano::unchecked_key const & key, nano::unchecked_info const & info) { if (json_block_l) { boost::property_tree::ptree block_node_l; @@ -4140,8 +4139,7 @@ void nano::json_handler::unchecked () std::string contents; info.block->serialize_json (contents); unchecked.put (info.block->hash ().to_string (), contents); - } - } + } }, [iterations = 0, count = count] () mutable { return iterations++ < count; }); response_l.add_child ("blocks", unchecked); } response_errors (); @@ -4164,29 +4162,21 @@ void nano::json_handler::unchecked_get () if (!ec) { auto transaction (node.store.tx_begin_read ()); - for (auto [i, n] = node.unchecked.full_range (transaction); i != n; ++i) - { - nano::unchecked_key const & key (i->first); - if (key.hash == hash) + node.unchecked.for_each ( + transaction, hash, [this, &hash, &json_block_l] (nano::unchecked_key const & key, nano::unchecked_info const & info) { + response_l.put ("modified_timestamp", std::to_string (info.modified ())); + if (json_block_l) { - nano::unchecked_info const & info (i->second); - response_l.put ("modified_timestamp", std::to_string (info.modified ())); - - if (json_block_l) - { - boost::property_tree::ptree block_node_l; - info.block->serialize_json (block_node_l); - response_l.add_child ("contents", block_node_l); - } - else - { - std::string contents; - info.block->serialize_json (contents); - response_l.put ("contents", contents); - } - break; + boost::property_tree::ptree block_node_l; + info.block->serialize_json (block_node_l); + response_l.add_child ("contents", block_node_l); } - } + else + { + std::string contents; + info.block->serialize_json (contents); + response_l.put ("contents", contents); + } }, [iterations = 0] () mutable { return iterations++ < 1; }); if (response_l.empty ()) { ec = nano::error_blocks::not_found; @@ -4212,11 +4202,10 @@ void nano::json_handler::unchecked_keys () { boost::property_tree::ptree unchecked; auto transaction (node.store.tx_begin_read ()); - for (auto [i, n] = node.unchecked.equal_range (transaction, key); i != n && unchecked.size () < count; ++i) - { + node.unchecked.for_each ( + transaction, key, [&unchecked, json_block_l] (nano::unchecked_key const & key, nano::unchecked_info const & info) { boost::property_tree::ptree entry; - nano::unchecked_info const & info (i->second); - entry.put ("key", i->first.key ().to_string ()); + entry.put ("key", key.key ().to_string ()); entry.put ("hash", info.block->hash ().to_string ()); entry.put ("modified_timestamp", std::to_string (info.modified ())); if (json_block_l) @@ -4231,8 +4220,7 @@ void nano::json_handler::unchecked_keys () info.block->serialize_json (contents); entry.put ("contents", contents); } - unchecked.push_back (std::make_pair ("", entry)); - } + unchecked.push_back (std::make_pair ("", entry)); }, [&unchecked, &count] () { return unchecked.size () < count; }); response_l.add_child ("unchecked", unchecked); } response_errors (); diff --git a/nano/node/node.cpp b/nano/node/node.cpp index 8dbb942c9c..429cf557c3 100644 --- a/nano/node/node.cpp +++ b/nano/node/node.cpp @@ -866,7 +866,7 @@ void nano::node::ongoing_bootstrap () uint32_t frontiers_age (std::numeric_limits::max ()); auto bootstrap_weight_reached (ledger.cache.block_count >= ledger.bootstrap_weight_max_blocks); auto previous_bootstrap_count (stats.count (nano::stat::type::bootstrap, nano::stat::detail::initiate, nano::stat::dir::out) + stats.count (nano::stat::type::bootstrap, nano::stat::detail::initiate_legacy_age, nano::stat::dir::out)); - /* + /* - Maximum value for 25% of attempts or if block count is below preconfigured value (initial bootstrap not finished) - Node shutdown time minus 1 hour for start attempts (warm up) - Default age value otherwise (1 day for live network, 1 hour for beta) @@ -982,16 +982,13 @@ void nano::node::unchecked_cleanup () 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, n] = unchecked.full_range (transaction); 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); + unchecked.for_each ( + transaction, [this, &digests, &cleaning_list, &now] (nano::unchecked_key const & key, nano::unchecked_info const & info) { if ((now - info.modified ()) > static_cast (config.unchecked_cutoff_time.count ())) { digests.push_back (network.publish_filter.hash (info.block)); cleaning_list.push_back (key); - } - } + } }, [iterations = 0, count = 1024 * 1024] () mutable { return iterations++ < count; }); } if (!cleaning_list.empty ()) { diff --git a/nano/node/unchecked_map.cpp b/nano/node/unchecked_map.cpp index 1347bec4a7..fe22e25391 100644 --- a/nano/node/unchecked_map.cpp +++ b/nano/node/unchecked_map.cpp @@ -27,6 +27,24 @@ void nano::unchecked_map::put (nano::hash_or_account const & dependency, nano::u condition.notify_all (); // Notify run () } +void nano::unchecked_map::for_each ( +nano::transaction const & transaction, std::function action, std::function predicate) +{ + for (auto [i, n] = full_range (transaction); predicate () && i != n; ++i) + { + action (i->first, i->second); + } +} + +void nano::unchecked_map::for_each ( +nano::transaction const & transaction, nano::hash_or_account const & dependency, std::function action, std::function predicate) +{ + for (auto [i, n] = equal_range (transaction, dependency.as_block_hash ()); predicate () && i->first.key () == dependency && i != n; ++i) + { + action (i->first, i->second); + } +} + auto nano::unchecked_map::equal_range (nano::transaction const & transaction, nano::block_hash const & dependency) -> std::pair { return store.unchecked.equal_range (transaction, dependency); diff --git a/nano/node/unchecked_map.hpp b/nano/node/unchecked_map.hpp index 76b882ee75..26c39d6526 100644 --- a/nano/node/unchecked_map.hpp +++ b/nano/node/unchecked_map.hpp @@ -17,15 +17,14 @@ class unchecked_key; class write_transaction; class unchecked_map { -public: - using iterator = nano::unchecked_store::iterator; - public: unchecked_map (nano::store & store, bool const & do_delete); ~unchecked_map (); void put (nano::hash_or_account const & dependency, nano::unchecked_info const & info); - std::pair equal_range (nano::transaction const & transaction, nano::block_hash const & dependency); - std::pair full_range (nano::transaction const & transaction); + void for_each ( + nano::transaction const & transaction, std::function action, std::function predicate = [] () { return true; }); + void for_each ( + nano::transaction const & transaction, nano::hash_or_account const & dependency, std::function action, std::function predicate = [] () { return true; }); std::vector get (nano::transaction const &, nano::block_hash const &); bool exists (nano::transaction const & transaction, nano::unchecked_key const & key) const; void del (nano::write_transaction const & transaction, nano::unchecked_key const & key); @@ -39,6 +38,10 @@ class unchecked_map std::function satisfied{ [] (nano::unchecked_info const &) {} }; private: + using iterator = nano::unchecked_store::iterator; + std::pair equal_range (nano::transaction const & transaction, nano::block_hash const & dependency); + std::pair full_range (nano::transaction const & transaction); + using insert = std::pair; using query = nano::hash_or_account; class item_visitor : boost::static_visitor<> From 71ec1d71cd555148e449b91e1f7b01f02b46adf9 Mon Sep 17 00:00:00 2001 From: clemahieu Date: Wed, 8 Jun 2022 13:39:24 +0100 Subject: [PATCH 25/34] Reimplementing nano::unchecked_store::get in terms of unchecked_store::for_each and removing backend-specific variants. # Conflicts: # nano/node/lmdb/lmdb.cpp # nano/node/lmdb/lmdb.hpp # nano/node/rocksdb/rocksdb.cpp # nano/node/rocksdb/rocksdb.hpp # nano/secure/store/unchecked_store_partial.hpp --- nano/node/unchecked_map.cpp | 6 +++++- nano/secure/store.cpp | 18 +----------------- nano/secure/store.hpp | 3 +-- 3 files changed, 7 insertions(+), 20 deletions(-) diff --git a/nano/node/unchecked_map.cpp b/nano/node/unchecked_map.cpp index fe22e25391..3e7bb1418a 100644 --- a/nano/node/unchecked_map.cpp +++ b/nano/node/unchecked_map.cpp @@ -57,7 +57,11 @@ auto nano::unchecked_map::full_range (nano::transaction const & transaction) -> std::vector nano::unchecked_map::get (nano::transaction const & transaction, nano::block_hash const & hash) { - return store.unchecked.get (transaction, hash); + std::vector result; + for_each (transaction, hash, [&result] (nano::unchecked_key const & key, nano::unchecked_info const & info) { + result.push_back (info); + }); + return result; } bool nano::unchecked_map::exists (nano::transaction const & transaction, nano::unchecked_key const & key) const diff --git a/nano/secure/store.cpp b/nano/secure/store.cpp index dfaa3620d5..f4757cb0f6 100644 --- a/nano/secure/store.cpp +++ b/nano/secure/store.cpp @@ -167,20 +167,4 @@ auto nano::unchecked_store::equal_range (nano::transaction const & transaction, auto nano::unchecked_store::full_range (nano::transaction const & transaction) -> std::pair { return std::make_pair (begin (transaction), end ()); -} - -std::vector nano::unchecked_store::get (nano::transaction const & transaction, nano::block_hash const & dependency) -{ - auto range = equal_range (transaction, dependency); - std::vector result; - auto & i = range.first; - auto & n = range.second; - for (; i != n; ++i) - { - auto const & key = i->first; - auto const & value = i->second; - debug_assert (key.hash == value.block->hash ()); - result.push_back (value); - } - return result; -} +} \ No newline at end of file diff --git a/nano/secure/store.hpp b/nano/secure/store.hpp index 2b22aae571..722e7e8a2a 100644 --- a/nano/secure/store.hpp +++ b/nano/secure/store.hpp @@ -518,7 +518,7 @@ class store_iterator final return *this; } nano::store_iterator & operator= (nano::store_iterator const &) = delete; - std::pair * operator-> () + std::pair * operator->() { return ¤t; } @@ -756,7 +756,6 @@ class unchecked_store virtual void put (nano::write_transaction const &, nano::hash_or_account const & dependency, nano::unchecked_info const &) = 0; std::pair equal_range (nano::transaction const & transaction, nano::block_hash const & dependency); std::pair full_range (nano::transaction const & transaction); - std::vector get (nano::transaction const &, nano::block_hash const &); 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 iterator begin (nano::transaction const &) const = 0; From 17f281b781a938aed2bfa65bf118ee9cc1eb4318 Mon Sep 17 00:00:00 2001 From: clemahieu Date: Wed, 8 Jun 2022 15:46:39 +0100 Subject: [PATCH 26/34] Adding a memory container for blocks once the initial bootstrap threshold is reached. Blocks are pruned in fifo order. # Conflicts: # nano/node/node.cpp # nano/secure/store/unchecked_store_partial.hpp --- nano/node/node.cpp | 1 + nano/node/unchecked_map.cpp | 146 +++++++++++++++++++++++++++--------- nano/node/unchecked_map.hpp | 41 +++++++++- nano/secure/common.cpp | 5 ++ nano/secure/common.hpp | 1 + 5 files changed, 155 insertions(+), 39 deletions(-) diff --git a/nano/node/node.cpp b/nano/node/node.cpp index 429cf557c3..4badd3d2aa 100644 --- a/nano/node/node.cpp +++ b/nano/node/node.cpp @@ -158,6 +158,7 @@ nano::node::node (boost::asio::io_context & io_ctx_a, boost::filesystem::path co startup_time (std::chrono::steady_clock::now ()), node_seq (seq) { + unchecked.use_memory = [this] () { return ledger.bootstrap_weight_reached (); }; unchecked.satisfied = [this] (nano::unchecked_info const & info) { this->block_processor.add (info); }; diff --git a/nano/node/unchecked_map.cpp b/nano/node/unchecked_map.cpp index 3e7bb1418a..292fe5e384 100644 --- a/nano/node/unchecked_map.cpp +++ b/nano/node/unchecked_map.cpp @@ -30,29 +30,41 @@ void nano::unchecked_map::put (nano::hash_or_account const & dependency, nano::u void nano::unchecked_map::for_each ( nano::transaction const & transaction, std::function action, std::function predicate) { - for (auto [i, n] = full_range (transaction); predicate () && i != n; ++i) + nano::lock_guard lock{ mutex_entries }; + if (entries == nullptr) { - action (i->first, i->second); + for (auto [i, n] = store.unchecked.full_range (transaction); predicate () && i != n; ++i) + { + action (i->first, i->second); + } + } + else + { + for (auto i = entries->begin (), n = entries->end (); predicate () && i != n; ++i) + { + action (i->key, i->info); + } } } void nano::unchecked_map::for_each ( nano::transaction const & transaction, nano::hash_or_account const & dependency, std::function action, std::function predicate) { - for (auto [i, n] = equal_range (transaction, dependency.as_block_hash ()); predicate () && i->first.key () == dependency && i != n; ++i) + nano::lock_guard lock{ mutex_entries }; + if (entries == nullptr) { - action (i->first, i->second); + for (auto [i, n] = store.unchecked.equal_range (transaction, dependency.as_block_hash ()); predicate () && i->first.key () == dependency && i != n; ++i) + { + action (i->first, i->second); + } + } + else + { + for (auto i = entries->template get ().lower_bound (nano::unchecked_key{ dependency, 0 }), n = entries->template get ().end (); predicate () && i != n && i->key.key () == dependency; ++i) + { + action (i->key, i->info); + } } -} - -auto nano::unchecked_map::equal_range (nano::transaction const & transaction, nano::block_hash const & dependency) -> std::pair -{ - return store.unchecked.equal_range (transaction, dependency); -} - -auto nano::unchecked_map::full_range (nano::transaction const & transaction) -> std::pair -{ - return store.unchecked.full_range (transaction); } std::vector nano::unchecked_map::get (nano::transaction const & transaction, nano::block_hash const & hash) @@ -66,22 +78,55 @@ std::vector nano::unchecked_map::get (nano::transaction co bool nano::unchecked_map::exists (nano::transaction const & transaction, nano::unchecked_key const & key) const { - return store.unchecked.exists (transaction, key); + nano::lock_guard lock{ mutex_entries }; + if (entries == nullptr) + { + return store.unchecked.exists (transaction, key); + } + else + { + return entries->template get ().count (key) != 0; + } } void nano::unchecked_map::del (nano::write_transaction const & transaction, nano::unchecked_key const & key) { - store.unchecked.del (transaction, key); + nano::lock_guard lock{ mutex_entries }; + if (entries == nullptr) + { + store.unchecked.del (transaction, key); + } + else + { + auto erased = entries->template get ().erase (key); + release_assert (erased); + } } void nano::unchecked_map::clear (nano::write_transaction const & transaction) { - store.unchecked.clear (transaction); + nano::lock_guard lock{ mutex_entries }; + if (entries == nullptr) + { + store.unchecked.clear (transaction); + } + else + { + entries->clear (); + } } size_t nano::unchecked_map::count (nano::transaction const & transaction) const { - return store.unchecked.count (transaction); + nano::lock_guard lock{ mutex_entries }; + if (entries == nullptr) + { + return store.unchecked.count (transaction); + } + else + { + return entries->size (); + } } void nano::unchecked_map::stop () @@ -116,30 +161,16 @@ nano::unchecked_map::item_visitor::item_visitor (unchecked_map & unchecked, nano transaction{ transaction } { } + void nano::unchecked_map::item_visitor::operator() (insert const & item) { auto const & [dependency, info] = item; - unchecked.store.unchecked.put (transaction, dependency, { info.block, info.account, info.verified }); + unchecked.insert_impl (transaction, dependency, info); } void nano::unchecked_map::item_visitor::operator() (query const & item) { - auto [i, n] = unchecked.store.unchecked.equal_range (transaction, item.hash); - std::deque delete_queue; - for (; i != n; ++i) - { - auto const & key = i->first; - auto const & info = i->second; - delete_queue.push_back (key); - unchecked.satisfied (info); - } - if (!unchecked.disable_delete) - { - for (auto const & key : delete_queue) - { - unchecked.del (transaction, key); - } - } + unchecked.query_impl (transaction, item.hash); } void nano::unchecked_map::write_buffer (decltype (buffer) const & back_buffer) @@ -177,3 +208,48 @@ void nano::unchecked_map::run () } } } + +void nano::unchecked_map::insert_impl (nano::write_transaction const & transaction, nano::hash_or_account const & dependency, nano::unchecked_info const & info) +{ + nano::lock_guard lock{ mutex_entries }; + // Check if we should be using memory but the memory container hasn't been constructed i.e. we're transitioning from disk to memory. + if (entries == nullptr && use_memory ()) + { + auto entries_new = std::make_unique (); + for_each ( + transaction, [&entries_new] (nano::unchecked_key const & key, nano::unchecked_info const & info) { entries_new->template get ().insert ({ key, info }); }, [&] () { return entries_new->size () < mem_block_count_max; }); + clear (transaction); + entries = std::move (entries_new); + } + if (entries == nullptr) + { + store.unchecked.put (transaction, dependency, { info.block, info.account, info.verified }); + } + else + { + nano::unchecked_key key{ dependency, info.block->hash () }; + entries->template get ().insert ({ key, info }); + while (entries->size () > mem_block_count_max) + { + entries->template get ().pop_front (); + } + } +} + +void nano::unchecked_map::query_impl (nano::write_transaction const & transaction, nano::block_hash const & hash) +{ + nano::lock_guard lock{ mutex_entries }; + + std::deque delete_queue; + for_each (transaction, hash, [this, &delete_queue] (nano::unchecked_key const & key, nano::unchecked_info const & info) { + delete_queue.push_back (key); + satisfied (info); + }); + if (!disable_delete) + { + for (auto const & key : delete_queue) + { + del (transaction, key); + } + } +} \ No newline at end of file diff --git a/nano/node/unchecked_map.hpp b/nano/node/unchecked_map.hpp index 26c39d6526..326b13c836 100644 --- a/nano/node/unchecked_map.hpp +++ b/nano/node/unchecked_map.hpp @@ -4,10 +4,17 @@ #include #include +#include +#include +#include +#include + #include #include #include +namespace mi = boost::multi_index; + namespace nano { class store; @@ -17,6 +24,13 @@ class unchecked_key; class write_transaction; class unchecked_map { + class tag_random_access + { + }; + class tag_root + { + }; + public: unchecked_map (nano::store & store, bool const & do_delete); ~unchecked_map (); @@ -33,15 +47,13 @@ class unchecked_map void stop (); void flush (); + std::function use_memory = [] () { return true; }; + public: // Trigger requested dependencies void trigger (nano::hash_or_account const & dependency); std::function satisfied{ [] (nano::unchecked_info const &) {} }; private: - using iterator = nano::unchecked_store::iterator; - std::pair equal_range (nano::transaction const & transaction, nano::block_hash const & dependency); - std::pair full_range (nano::transaction const & transaction); - using insert = std::pair; using query = nano::hash_or_account; class item_visitor : boost::static_visitor<> @@ -54,6 +66,8 @@ class unchecked_map nano::write_transaction const & transaction; }; void run (); + void insert_impl (nano::write_transaction const & transaction, nano::hash_or_account const & dependency, nano::unchecked_info const & info); + void query_impl (nano::write_transaction const & transaction, nano::block_hash const & hash); nano::store & store; bool const & disable_delete; std::deque> buffer; @@ -64,5 +78,24 @@ class unchecked_map nano::mutex mutex; std::thread thread; void write_buffer (decltype (buffer) const & back_buffer); + + static size_t constexpr mem_block_count_max = 256'000; + + friend class item_visitor; + +private: // In memory store + class entry + { + public: + nano::unchecked_key key; + nano::unchecked_info info; + }; + mutable std::recursive_mutex mutex_entries; + std::unique_ptr>, + mi::ordered_unique, + mi::member>>>> + entries; }; } diff --git a/nano/secure/common.cpp b/nano/secure/common.cpp index 865d9bc661..474f5ff466 100644 --- a/nano/secure/common.cpp +++ b/nano/secure/common.cpp @@ -739,6 +739,11 @@ bool nano::unchecked_key::operator== (nano::unchecked_key const & other_a) const return previous == other_a.previous && hash == other_a.hash; } +bool nano::unchecked_key::operator< (nano::unchecked_key const & other_a) const +{ + return previous != other_a.previous ? previous < other_a.previous : hash < other_a.hash; +} + nano::block_hash const & nano::unchecked_key::key () const { return previous; diff --git a/nano/secure/common.hpp b/nano/secure/common.hpp index 879b55d815..1f4b3b407b 100644 --- a/nano/secure/common.hpp +++ b/nano/secure/common.hpp @@ -176,6 +176,7 @@ class unchecked_key final unchecked_key (nano::uint512_union const &); bool deserialize (nano::stream &); bool operator== (nano::unchecked_key const &) const; + bool operator< (nano::unchecked_key const &) const; nano::block_hash const & key () const; nano::block_hash previous{ 0 }; nano::block_hash hash{ 0 }; From bf54411142229268fe5e36d5f29be01232f357cf Mon Sep 17 00:00:00 2001 From: clemahieu Date: Thu, 9 Jun 2022 16:34:15 +0100 Subject: [PATCH 27/34] Commenting the transition from disk to memory. Fixing rpc.unchecked_get which didn't get translated properly with the for_each conversion. # Conflicts: # nano/node/json_handler.cpp # nano/secure/store/unchecked_store_partial.hpp --- nano/node/json_handler.cpp | 33 +++++++++++++++++++-------------- 1 file changed, 19 insertions(+), 14 deletions(-) diff --git a/nano/node/json_handler.cpp b/nano/node/json_handler.cpp index b221c86b54..8095d5c534 100644 --- a/nano/node/json_handler.cpp +++ b/nano/node/json_handler.cpp @@ -4161,22 +4161,27 @@ void nano::json_handler::unchecked_get () auto hash (hash_impl ()); if (!ec) { - auto transaction (node.store.tx_begin_read ()); + bool done = false; node.unchecked.for_each ( - transaction, hash, [this, &hash, &json_block_l] (nano::unchecked_key const & key, nano::unchecked_info const & info) { - response_l.put ("modified_timestamp", std::to_string (info.modified ())); - if (json_block_l) - { - boost::property_tree::ptree block_node_l; - info.block->serialize_json (block_node_l); - response_l.add_child ("contents", block_node_l); - } - else + node.store.tx_begin_read (), [&] (nano::unchecked_key const & key, nano::unchecked_info const & info) { + if (key.hash == hash) { - std::string contents; - info.block->serialize_json (contents); - response_l.put ("contents", contents); - } }, [iterations = 0] () mutable { return iterations++ < 1; }); + response_l.put ("modified_timestamp", std::to_string (info.modified ())); + + if (json_block_l) + { + boost::property_tree::ptree block_node_l; + info.block->serialize_json (block_node_l); + response_l.add_child ("contents", block_node_l); + } + else + { + std::string contents; + info.block->serialize_json (contents); + response_l.put ("contents", contents); + } + done = true; + } }, [&] () { return !done; }); if (response_l.empty ()) { ec = nano::error_blocks::not_found; From cfe33571df075bf5d98c33c898cf09c7458f5710 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20Wo=CC=81jcik?= <3044353+fikumikudev@users.noreply.github.com> Date: Fri, 10 Jun 2022 19:35:41 +0200 Subject: [PATCH 28/34] Cleanup of the leftover code --- nano/nano_node/entry.cpp | 2 +- nano/node/blockprocessor.cpp | 54 --------------------------- nano/node/lmdb/unchecked_store.cpp | 4 -- nano/node/rocksdb/unchecked_store.cpp | 4 -- nano/node/unchecked_map.cpp | 16 ++++---- nano/node/unchecked_map.hpp | 16 ++++---- 6 files changed, 18 insertions(+), 78 deletions(-) diff --git a/nano/nano_node/entry.cpp b/nano/nano_node/entry.cpp index ed493c0f63..3bbc0a0452 100644 --- a/nano/nano_node/entry.cpp +++ b/nano/nano_node/entry.cpp @@ -439,7 +439,7 @@ int main (int argc, char * const * argv) } // Check all unchecked keys for matching frontier hashes. Indicates an issue with process_batch algorithm - node->store.unchecked.for_each (transaction, [&frontier_hashes] (nano::unchecked_key const & key, nano::unchecked_info const & info) { + node->unchecked.for_each (transaction, [&frontier_hashes] (nano::unchecked_key const & key, nano::unchecked_info const & info) { auto it = frontier_hashes.find (key.key ()); if (it != frontier_hashes.cend ()) { diff --git a/nano/node/blockprocessor.cpp b/nano/node/blockprocessor.cpp index 98d3c9e4be..6dba3fd3dd 100644 --- a/nano/node/blockprocessor.cpp +++ b/nano/node/blockprocessor.cpp @@ -382,24 +382,6 @@ nano::process_return nano::block_processor::process_one (nano::write_transaction } info_a.verified = result.verified; - //<<<<<<< HEAD - // node.unchecked.put (block->previous (), info_a); - //======= - // if (info_a.modified == 0) - // { - // info_a.modified = nano::seconds_since_epoch (); - // } - // - // nano::unchecked_key unchecked_key (block->previous (), hash); - // if (node.ledger.bootstrap_weight_reached () && node.store.unchecked.count (transaction_a) > max) - // { - // node.store.unchecked.clear (transaction_a); - // } - // node.store.unchecked.put (transaction_a, unchecked_key, info_a); - // - //>>>>>>> d4a4299b (Bound the unchecked store after the initial bootstrap amount has been reached. This prevents the unchecked table size from increasing beyond reasonable bounds when it's in sync.) - - // No need to check for unchecked store size, it will be bounded by subsequent unchecked-in-memory feature debug_assert (info_a.modified () != 0); node.unchecked.put (block->previous (), info_a); @@ -415,24 +397,6 @@ nano::process_return nano::block_processor::process_one (nano::write_transaction } info_a.verified = result.verified; - //<<<<<<< HEAD - // node.unchecked.put (node.ledger.block_source (transaction_a, *(block)), info_a); - //======= - // if (info_a.modified == 0) - // { - // info_a.modified = nano::seconds_since_epoch (); - // } - // - // nano::unchecked_key unchecked_key (node.ledger.block_source (transaction_a, *(block)), hash); - // if (node.ledger.bootstrap_weight_reached () && node.store.unchecked.count (transaction_a) > max) - // { - // node.store.unchecked.clear (transaction_a); - // } - // node.store.unchecked.put (transaction_a, unchecked_key, info_a); - // - //>>>>>>> d4a4299b (Bound the unchecked store after the initial bootstrap amount has been reached. This prevents the unchecked table size from increasing beyond reasonable bounds when it's in sync.) - - // No need to check for unchecked store size, it will be bounded by subsequent unchecked-in-memory feature debug_assert (info_a.modified () != 0); node.unchecked.put (node.ledger.block_source (transaction_a, *(block)), info_a); @@ -448,24 +412,6 @@ nano::process_return nano::block_processor::process_one (nano::write_transaction } info_a.verified = result.verified; - //<<<<<<< HEAD - // node.unchecked.put (block->account (), info_a); // Specific unchecked key starting with epoch open block account public key - //======= - // if (info_a.modified == 0) - // { - // info_a.modified = nano::seconds_since_epoch (); - // } - // - // nano::unchecked_key unchecked_key (block->account (), hash); // Specific unchecked key starting with epoch open block account public key - // if (node.ledger.bootstrap_weight_reached () && node.store.unchecked.count (transaction_a) > max) - // { - // node.store.unchecked.clear (transaction_a); - // } - // node.store.unchecked.put (transaction_a, unchecked_key, info_a); - // - //>>>>>>> d4a4299b (Bound the unchecked store after the initial bootstrap amount has been reached. This prevents the unchecked table size from increasing beyond reasonable bounds when it's in sync.) - - // No need to check for unchecked store size, it will be bounded by subsequent unchecked-in-memory feature debug_assert (info_a.modified () != 0); node.unchecked.put (block->account (), info_a); // Specific unchecked key starting with epoch open block account public key diff --git a/nano/node/lmdb/unchecked_store.cpp b/nano/node/lmdb/unchecked_store.cpp index 3020bda57d..e969fffd80 100644 --- a/nano/node/lmdb/unchecked_store.cpp +++ b/nano/node/lmdb/unchecked_store.cpp @@ -13,10 +13,6 @@ void nano::lmdb::unchecked_store::clear (nano::write_transaction const & transac void nano::lmdb::unchecked_store::put (nano::write_transaction const & transaction_a, nano::hash_or_account const & dependency, nano::unchecked_info const & info) { - if (get (transaction_a, dependency.as_block_hash ()).size () > 1) - { - return; - } auto status = store.put (transaction_a, tables::unchecked, nano::unchecked_key{ dependency, info.block->hash () }, info); store.release_assert_success (status); } diff --git a/nano/node/rocksdb/unchecked_store.cpp b/nano/node/rocksdb/unchecked_store.cpp index 50e5c739b0..3e8c266ea8 100644 --- a/nano/node/rocksdb/unchecked_store.cpp +++ b/nano/node/rocksdb/unchecked_store.cpp @@ -13,10 +13,6 @@ void nano::rocksdb::unchecked_store::clear (nano::write_transaction const & tran void nano::rocksdb::unchecked_store::put (nano::write_transaction const & transaction_a, nano::hash_or_account const & dependency, nano::unchecked_info const & info) { - if (get (transaction_a, dependency.as_block_hash ()).size () > 1) - { - return; - } auto status = store.put (transaction_a, tables::unchecked, nano::unchecked_key{ dependency, info.block->hash () }, info); store.release_assert_success (status); } diff --git a/nano/node/unchecked_map.cpp b/nano/node/unchecked_map.cpp index 292fe5e384..bcc1064a89 100644 --- a/nano/node/unchecked_map.cpp +++ b/nano/node/unchecked_map.cpp @@ -30,7 +30,7 @@ void nano::unchecked_map::put (nano::hash_or_account const & dependency, nano::u void nano::unchecked_map::for_each ( nano::transaction const & transaction, std::function action, std::function predicate) { - nano::lock_guard lock{ mutex_entries }; + nano::lock_guard lock{ entries_mutex }; if (entries == nullptr) { for (auto [i, n] = store.unchecked.full_range (transaction); predicate () && i != n; ++i) @@ -50,7 +50,7 @@ nano::transaction const & transaction, std::function action, std::function predicate) { - nano::lock_guard lock{ mutex_entries }; + nano::lock_guard lock{ entries_mutex }; if (entries == nullptr) { for (auto [i, n] = store.unchecked.equal_range (transaction, dependency.as_block_hash ()); predicate () && i->first.key () == dependency && i != n; ++i) @@ -78,7 +78,7 @@ std::vector nano::unchecked_map::get (nano::transaction co bool nano::unchecked_map::exists (nano::transaction const & transaction, nano::unchecked_key const & key) const { - nano::lock_guard lock{ mutex_entries }; + nano::lock_guard lock{ entries_mutex }; if (entries == nullptr) { return store.unchecked.exists (transaction, key); @@ -91,7 +91,7 @@ bool nano::unchecked_map::exists (nano::transaction const & transaction, nano::u void nano::unchecked_map::del (nano::write_transaction const & transaction, nano::unchecked_key const & key) { - nano::lock_guard lock{ mutex_entries }; + nano::lock_guard lock{ entries_mutex }; if (entries == nullptr) { store.unchecked.del (transaction, key); @@ -105,7 +105,7 @@ void nano::unchecked_map::del (nano::write_transaction const & transaction, nano void nano::unchecked_map::clear (nano::write_transaction const & transaction) { - nano::lock_guard lock{ mutex_entries }; + nano::lock_guard lock{ entries_mutex }; if (entries == nullptr) { store.unchecked.clear (transaction); @@ -118,7 +118,7 @@ void nano::unchecked_map::clear (nano::write_transaction const & transaction) size_t nano::unchecked_map::count (nano::transaction const & transaction) const { - nano::lock_guard lock{ mutex_entries }; + nano::lock_guard lock{ entries_mutex }; if (entries == nullptr) { return store.unchecked.count (transaction); @@ -211,7 +211,7 @@ void nano::unchecked_map::run () void nano::unchecked_map::insert_impl (nano::write_transaction const & transaction, nano::hash_or_account const & dependency, nano::unchecked_info const & info) { - nano::lock_guard lock{ mutex_entries }; + nano::lock_guard lock{ entries_mutex }; // Check if we should be using memory but the memory container hasn't been constructed i.e. we're transitioning from disk to memory. if (entries == nullptr && use_memory ()) { @@ -238,7 +238,7 @@ void nano::unchecked_map::insert_impl (nano::write_transaction const & transacti void nano::unchecked_map::query_impl (nano::write_transaction const & transaction, nano::block_hash const & hash) { - nano::lock_guard lock{ mutex_entries }; + nano::lock_guard lock{ entries_mutex }; std::deque delete_queue; for_each (transaction, hash, [this, &delete_queue] (nano::unchecked_key const & key, nano::unchecked_info const & info) { diff --git a/nano/node/unchecked_map.hpp b/nano/node/unchecked_map.hpp index 326b13c836..c48c9a27c1 100644 --- a/nano/node/unchecked_map.hpp +++ b/nano/node/unchecked_map.hpp @@ -90,12 +90,14 @@ class unchecked_map nano::unchecked_key key; nano::unchecked_info info; }; - mutable std::recursive_mutex mutex_entries; - std::unique_ptr>, - mi::ordered_unique, - mi::member>>>> - entries; + // clang-format off + using ordered_unchecked = boost::multi_index_container>, + mi::ordered_unique, + mi::member>>>; + // clang-format on + std::unique_ptr entries; + mutable std::recursive_mutex entries_mutex; }; } From 769019f59b77ba5993dc5a3bdb167ef8f6ac9569 Mon Sep 17 00:00:00 2001 From: Dimitrios Siganos Date: Wed, 8 Jun 2022 17:04:04 +0100 Subject: [PATCH 29/34] Fix use after delete in cleanup_election() fixes #154 # Conflicts: # nano/node/active_transactions.cpp --- nano/node/active_transactions.cpp | 26 +++++++++++++------------- nano/node/active_transactions.hpp | 2 +- 2 files changed, 14 insertions(+), 14 deletions(-) diff --git a/nano/node/active_transactions.cpp b/nano/node/active_transactions.cpp index a403dbcd55..454abbdeda 100644 --- a/nano/node/active_transactions.cpp +++ b/nano/node/active_transactions.cpp @@ -348,14 +348,14 @@ void nano::active_transactions::request_confirm (nano::unique_lock } } -void nano::active_transactions::cleanup_election (nano::unique_lock & lock_a, nano::election const & election) +void nano::active_transactions::cleanup_election (nano::unique_lock & lock_a, std::shared_ptr election) { debug_assert (lock_a.owns_lock ()); - if (!election.confirmed ()) + if (!election->confirmed ()) { node.stats.inc (nano::stat::type::election, nano::stat::detail::election_drop_all); - if (election.behavior == election_behavior::hinted) + if (election->behavior == election_behavior::hinted) { node.stats.inc (nano::stat::type::election, nano::stat::detail::election_hinted_drop); } @@ -363,18 +363,18 @@ void nano::active_transactions::cleanup_election (nano::unique_lock else { node.stats.inc (nano::stat::type::election, nano::stat::detail::election_confirmed_all); - if (election.behavior == election_behavior::hinted) + if (election->behavior == election_behavior::hinted) { node.stats.inc (nano::stat::type::election, nano::stat::detail::election_hinted_confirmed); } } - if (election.behavior == election_behavior::hinted) + if (election->behavior == election_behavior::hinted) { --active_hinted_elections_count; } - auto blocks_l = election.blocks (); + auto blocks_l = election->blocks (); for (auto const & [hash, block] : blocks_l) { auto erased (blocks.erase (hash)); @@ -382,29 +382,29 @@ void nano::active_transactions::cleanup_election (nano::unique_lock debug_assert (erased == 1); erase_inactive_votes_cache (hash); } - roots.get ().erase (roots.get ().find (election.qualified_root)); + roots.get ().erase (roots.get ().find (election->qualified_root)); lock_a.unlock (); vacancy_update (); for (auto const & [hash, block] : blocks_l) { // Notify observers about dropped elections & blocks lost confirmed elections - if (!election.confirmed () || hash != election.winner ()->hash ()) + if (!election->confirmed () || hash != election->winner ()->hash ()) { node.observers.active_stopped.notify (hash); } - if (!election.confirmed ()) + if (!election->confirmed ()) { // Clear from publish filter node.network.publish_filter.clear (block); } } - node.stats.inc (nano::stat::type::election, election.confirmed () ? nano::stat::detail::election_confirmed : nano::stat::detail::election_not_confirmed); + node.stats.inc (nano::stat::type::election, election->confirmed () ? nano::stat::detail::election_confirmed : nano::stat::detail::election_not_confirmed); if (node.config.logging.election_result_logging ()) { - node.logger.try_log (boost::str (boost::format ("Election erased for root %1%, confirmed: %2$b") % election.qualified_root.to_string () % election.confirmed ())); + node.logger.try_log (boost::str (boost::format ("Election erased for root %1%, confirmed: %2$b") % election->qualified_root.to_string () % election->confirmed ())); } } @@ -1029,7 +1029,7 @@ void nano::active_transactions::erase (nano::qualified_root const & root_a) auto root_it (roots.get ().find (root_a)); if (root_it != roots.get ().end ()) { - cleanup_election (lock, *root_it->election); + cleanup_election (lock, root_it->election); } } @@ -1047,7 +1047,7 @@ void nano::active_transactions::erase_oldest () { node.stats.inc (nano::stat::type::election, nano::stat::detail::election_drop_overflow); auto item = roots.get ().front (); - cleanup_election (lock, *item.election); + cleanup_election (lock, item.election); } } diff --git a/nano/node/active_transactions.hpp b/nano/node/active_transactions.hpp index 47b36d8217..cebbc6d23d 100644 --- a/nano/node/active_transactions.hpp +++ b/nano/node/active_transactions.hpp @@ -198,7 +198,7 @@ class active_transactions final void request_confirm (nano::unique_lock &); void erase (nano::qualified_root const &); // 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 &); + void cleanup_election (nano::unique_lock & lock_a, std::shared_ptr); // Returns a list of elections sorted by difficulty, mutex must be locked std::vector> list_active_impl (std::size_t) const; From 94b913f6703c855df0ffec4b1b1a47080e8a8904 Mon Sep 17 00:00:00 2001 From: clemahieu Date: Mon, 27 Jun 2022 15:37:12 +0100 Subject: [PATCH 30/34] Formatting. --- nano/secure/store.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/nano/secure/store.hpp b/nano/secure/store.hpp index 722e7e8a2a..c4e41aa6be 100644 --- a/nano/secure/store.hpp +++ b/nano/secure/store.hpp @@ -518,7 +518,7 @@ class store_iterator final return *this; } nano::store_iterator & operator= (nano::store_iterator const &) = delete; - std::pair * operator->() + std::pair * operator-> () { return ¤t; } From 5111bfccb835a8992eb3bbe8ecb3986b93990215 Mon Sep 17 00:00:00 2001 From: JerzyStanislawski <49572068+JerzyStanislawski@users.noreply.github.com> Date: Fri, 8 Jul 2022 15:56:55 +0200 Subject: [PATCH 31/34] Block constructors to builders conversion in unit tests (#3841) * Block constructors to builders conversion in unit tests * Formatting fix --- nano/core_test/block.cpp | 187 +- nano/core_test/block_store.cpp | 1131 ++++-- nano/core_test/bootstrap.cpp | 212 +- nano/core_test/confirmation_height.cpp | 1166 ++++-- nano/core_test/confirmation_solicitor.cpp | 30 +- nano/core_test/conflicts.cpp | 64 +- nano/core_test/frontiers_confirmation.cpp | 303 +- nano/core_test/gap_cache.cpp | 77 +- nano/core_test/ledger.cpp | 3992 ++++++++++++++++----- nano/core_test/message.cpp | 76 +- nano/core_test/message_parser.cpp | 42 +- nano/core_test/network.cpp | 125 +- nano/core_test/node.cpp | 38 +- nano/core_test/prioritization.cpp | 60 +- nano/core_test/processor_service.cpp | 40 +- nano/core_test/request_aggregator.cpp | 72 +- nano/core_test/signing.cpp | 97 +- nano/core_test/system.cpp | 20 +- nano/core_test/unchecked_map.cpp | 10 +- nano/core_test/wallet.cpp | 12 +- nano/core_test/wallets.cpp | 53 +- nano/core_test/websocket.cpp | 30 +- nano/core_test/work_pool.cpp | 29 +- nano/nano_node/entry.cpp | 12 +- nano/rpc_test/rpc.cpp | 1322 +++++-- nano/slow_test/node.cpp | 489 ++- 26 files changed, 7730 insertions(+), 1959 deletions(-) diff --git a/nano/core_test/block.cpp b/nano/core_test/block.cpp index 3e2274d83b..8e1e3c7ea8 100644 --- a/nano/core_test/block.cpp +++ b/nano/core_test/block.cpp @@ -25,20 +25,36 @@ TEST (ed25519, signing) TEST (transaction_block, empty) { nano::keypair key1; - nano::send_block block (0, 1, 13, key1.prv, key1.pub, 2); - auto hash (block.hash ()); - ASSERT_FALSE (nano::validate_message (key1.pub, hash, block.signature)); - block.signature.bytes[32] ^= 0x1; - ASSERT_TRUE (nano::validate_message (key1.pub, hash, block.signature)); + nano::block_builder builder; + auto block = builder + .send () + .previous (0) + .destination (1) + .balance (13) + .sign (key1.prv, key1.pub) + .work (2) + .build (); + auto hash (block->hash ()); + ASSERT_FALSE (nano::validate_message (key1.pub, hash, block->signature)); + block->signature.bytes[32] ^= 0x1; + ASSERT_TRUE (nano::validate_message (key1.pub, hash, block->signature)); } TEST (block, send_serialize) { - nano::send_block block1 (0, 1, 2, nano::keypair ().prv, 4, 5); + nano::block_builder builder; + auto block1 = builder + .send () + .previous (0) + .destination (1) + .balance (2) + .sign (nano::keypair ().prv, 4) + .work (5) + .build (); std::vector bytes; { nano::vectorstream stream1 (bytes); - block1.serialize (stream1); + block1->serialize (stream1); } auto data (bytes.data ()); auto size (bytes.size ()); @@ -48,14 +64,22 @@ TEST (block, send_serialize) bool error (false); nano::send_block block2 (error, stream2); ASSERT_FALSE (error); - ASSERT_EQ (block1, block2); + ASSERT_EQ (*block1, block2); } TEST (block, send_serialize_json) { - nano::send_block block1 (0, 1, 2, nano::keypair ().prv, 4, 5); + nano::block_builder builder; + auto block1 = builder + .send () + .previous (0) + .destination (1) + .balance (2) + .sign (nano::keypair ().prv, 4) + .work (5) + .build (); std::string string1; - block1.serialize_json (string1); + block1->serialize_json (string1); ASSERT_NE (0, string1.size ()); boost::property_tree::ptree tree1; std::stringstream istream (string1); @@ -63,30 +87,44 @@ TEST (block, send_serialize_json) bool error (false); nano::send_block block2 (error, tree1); ASSERT_FALSE (error); - ASSERT_EQ (block1, block2); + ASSERT_EQ (*block1, block2); } TEST (block, receive_serialize) { - nano::receive_block block1 (0, 1, nano::keypair ().prv, 3, 4); + nano::block_builder builder; + auto block1 = builder + .receive () + .previous (0) + .source (1) + .sign (nano::keypair ().prv, 3) + .work (4) + .build (); nano::keypair key1; std::vector bytes; { nano::vectorstream stream1 (bytes); - block1.serialize (stream1); + block1->serialize (stream1); } nano::bufferstream stream2 (bytes.data (), bytes.size ()); bool error (false); nano::receive_block block2 (error, stream2); ASSERT_FALSE (error); - ASSERT_EQ (block1, block2); + ASSERT_EQ (*block1, block2); } TEST (block, receive_serialize_json) { - nano::receive_block block1 (0, 1, nano::keypair ().prv, 3, 4); + nano::block_builder builder; + auto block1 = builder + .receive () + .previous (0) + .source (1) + .sign (nano::keypair ().prv, 3) + .work (4) + .build (); std::string string1; - block1.serialize_json (string1); + block1->serialize_json (string1); ASSERT_NE (0, string1.size ()); boost::property_tree::ptree tree1; std::stringstream istream (string1); @@ -94,14 +132,22 @@ TEST (block, receive_serialize_json) bool error (false); nano::receive_block block2 (error, tree1); ASSERT_FALSE (error); - ASSERT_EQ (block1, block2); + ASSERT_EQ (*block1, block2); } TEST (block, open_serialize_json) { - nano::open_block block1 (0, 1, 0, nano::keypair ().prv, 0, 0); + nano::block_builder builder; + auto block1 = builder + .open () + .source (0) + .representative (1) + .account (0) + .sign (nano::keypair ().prv, 0) + .work (0) + .build (); std::string string1; - block1.serialize_json (string1); + block1->serialize_json (string1); ASSERT_NE (0, string1.size ()); boost::property_tree::ptree tree1; std::stringstream istream (string1); @@ -109,14 +155,21 @@ TEST (block, open_serialize_json) bool error (false); nano::open_block block2 (error, tree1); ASSERT_FALSE (error); - ASSERT_EQ (block1, block2); + ASSERT_EQ (*block1, block2); } TEST (block, change_serialize_json) { - nano::change_block block1 (0, 1, nano::keypair ().prv, 3, 4); + nano::block_builder builder; + auto block1 = builder + .change () + .previous (0) + .representative (1) + .sign (nano::keypair ().prv, 3) + .work (4) + .build (); std::string string1; - block1.serialize_json (string1); + block1->serialize_json (string1); ASSERT_NE (0, string1.size ()); boost::property_tree::ptree tree1; std::stringstream istream (string1); @@ -124,7 +177,7 @@ TEST (block, change_serialize_json) bool error (false); nano::change_block block2 (error, tree1); ASSERT_FALSE (error); - ASSERT_EQ (block1, block2); + ASSERT_EQ (*block1, block2); } TEST (uint512_union, parse_zero) @@ -196,65 +249,95 @@ TEST (uint512_union, parse_error_overflow) TEST (send_block, deserialize) { - nano::send_block block1 (0, 1, 2, nano::keypair ().prv, 4, 5); - ASSERT_EQ (block1.hash (), block1.hash ()); + nano::block_builder builder; + auto block1 = builder + .send () + .previous (0) + .destination (1) + .balance (2) + .sign (nano::keypair ().prv, 4) + .work (5) + .build (); + ASSERT_EQ (block1->hash (), block1->hash ()); std::vector bytes; { nano::vectorstream stream1 (bytes); - block1.serialize (stream1); + block1->serialize (stream1); } ASSERT_EQ (nano::send_block::size, bytes.size ()); nano::bufferstream stream2 (bytes.data (), bytes.size ()); bool error (false); nano::send_block block2 (error, stream2); ASSERT_FALSE (error); - ASSERT_EQ (block1, block2); + ASSERT_EQ (*block1, block2); } TEST (receive_block, deserialize) { - nano::receive_block block1 (0, 1, nano::keypair ().prv, 3, 4); - ASSERT_EQ (block1.hash (), block1.hash ()); - block1.hashables.previous = 2; - block1.hashables.source = 4; + nano::block_builder builder; + auto block1 = builder + .receive () + .previous (0) + .source (1) + .sign (nano::keypair ().prv, 3) + .work (4) + .build (); + ASSERT_EQ (block1->hash (), block1->hash ()); + block1->hashables.previous = 2; + block1->hashables.source = 4; std::vector bytes; { nano::vectorstream stream1 (bytes); - block1.serialize (stream1); + block1->serialize (stream1); } ASSERT_EQ (nano::receive_block::size, bytes.size ()); nano::bufferstream stream2 (bytes.data (), bytes.size ()); bool error (false); nano::receive_block block2 (error, stream2); ASSERT_FALSE (error); - ASSERT_EQ (block1, block2); + ASSERT_EQ (*block1, block2); } TEST (open_block, deserialize) { - nano::open_block block1 (0, 1, 0, nano::keypair ().prv, 0, 0); - ASSERT_EQ (block1.hash (), block1.hash ()); + nano::block_builder builder; + auto block1 = builder + .open () + .source (0) + .representative (1) + .account (0) + .sign (nano::keypair ().prv, 0) + .work (0) + .build (); + ASSERT_EQ (block1->hash (), block1->hash ()); std::vector bytes; { nano::vectorstream stream (bytes); - block1.serialize (stream); + block1->serialize (stream); } ASSERT_EQ (nano::open_block::size, bytes.size ()); nano::bufferstream stream (bytes.data (), bytes.size ()); bool error (false); nano::open_block block2 (error, stream); ASSERT_FALSE (error); - ASSERT_EQ (block1, block2); + ASSERT_EQ (*block1, block2); } TEST (change_block, deserialize) { - nano::change_block block1 (1, 2, nano::keypair ().prv, 4, 5); - ASSERT_EQ (block1.hash (), block1.hash ()); + nano::block_builder builder; + auto block1 = builder + .change () + .previous (1) + .representative (2) + .sign (nano::keypair ().prv, 4) + .work (5) + .build (); + ASSERT_EQ (block1->hash (), block1->hash ()); std::vector bytes; { nano::vectorstream stream1 (bytes); - block1.serialize (stream1); + block1->serialize (stream1); } ASSERT_EQ (nano::change_block::size, bytes.size ()); auto data (bytes.data ()); @@ -265,7 +348,7 @@ TEST (change_block, deserialize) bool error (false); nano::change_block block2 (error, stream2); ASSERT_FALSE (error); - ASSERT_EQ (block1, block2); + ASSERT_EQ (*block1, block2); } TEST (frontier_req, serialization) @@ -292,7 +375,15 @@ 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::block_builder builder; + auto block = builder + .send () + .previous (0) + .destination (key2.pub) + .balance (200) + .sign (nano::keypair ().prv, 2) + .work (3) + .build_shared (); nano::publish req{ nano::dev::network_params.network, block }; std::vector bytes; { @@ -311,8 +402,16 @@ TEST (block, publish_req_serialization) TEST (block, difficulty) { - nano::send_block block (0, 1, 2, nano::keypair ().prv, 4, 5); - ASSERT_EQ (nano::dev::network_params.work.difficulty (block), nano::dev::network_params.work.difficulty (block.work_version (), block.root (), block.block_work ())); + nano::block_builder builder; + auto block = builder + .send () + .previous (0) + .destination (1) + .balance (2) + .sign (nano::keypair ().prv, 4) + .work (5) + .build (); + 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) diff --git a/nano/core_test/block_store.cpp b/nano/core_test/block_store.cpp index 299be5a784..225d51ec7d 100644 --- a/nano/core_test/block_store.cpp +++ b/nano/core_test/block_store.cpp @@ -116,17 +116,25 @@ TEST (block_store, add_item) nano::logger_mt logger; 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 ()); + nano::block_builder builder; + auto block = builder + .open () + .source (0) + .representative (1) + .account (0) + .sign (nano::keypair ().prv, 0) + .work (0) + .build (); + block->sideband_set ({}); + auto hash1 (block->hash ()); auto transaction (store->tx_begin_write ()); auto latest1 (store->block.get (transaction, hash1)); ASSERT_EQ (nullptr, latest1); ASSERT_FALSE (store->block.exists (transaction, hash1)); - store->block.put (transaction, hash1, block); + store->block.put (transaction, hash1, *block); auto latest2 (store->block.get (transaction, hash1)); ASSERT_NE (nullptr, latest2); - ASSERT_EQ (block, *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); @@ -139,28 +147,43 @@ TEST (block_store, clear_successor) nano::logger_mt logger; 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 ({}); + nano::block_builder builder; + auto block1 = builder + .open () + .source (0) + .representative (1) + .account (0) + .sign (nano::keypair ().prv, 0) + .work (0) + .build (); + block1->sideband_set ({}); auto transaction (store->tx_begin_write ()); - 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, block1->hash (), *block1); + auto block2 = builder + .open () + .source (0) + .representative (2) + .account (0) + .sign (nano::keypair ().prv, 0) + .work (0) + .build (); + block2->sideband_set ({}); + 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); + modified_sideband.successor = block2->hash (); + block1->sideband_set (modified_sideband); + 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); + 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 ()); } @@ -172,17 +195,25 @@ TEST (block_store, add_nonempty_block) 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); - block.sideband_set ({}); - auto hash1 (block.hash ()); - block.signature = nano::sign_message (key1.prv, key1.pub, hash1); + nano::block_builder builder; + auto block = builder + .open () + .source (0) + .representative (1) + .account (0) + .sign (nano::keypair ().prv, 0) + .work (0) + .build (); + block->sideband_set ({}); + 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)); ASSERT_EQ (nullptr, latest1); - store->block.put (transaction, hash1, block); + store->block.put (transaction, hash1, *block); auto latest2 (store->block.get (transaction, hash1)); ASSERT_NE (nullptr, latest2); - ASSERT_EQ (block, *latest2); + ASSERT_EQ (*block, *latest2); } TEST (block_store, add_two_items) @@ -191,28 +222,43 @@ TEST (block_store, add_two_items) 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); - block.sideband_set ({}); - auto hash1 (block.hash ()); - block.signature = nano::sign_message (key1.prv, key1.pub, hash1); + nano::block_builder builder; + auto block = builder + .open () + .source (0) + .representative (1) + .account (1) + .sign (nano::keypair ().prv, 0) + .work (0) + .build (); + block->sideband_set ({}); + 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)); 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 block2 = builder + .open () + .source (0) + .representative (1) + .account (3) + .sign (nano::keypair ().prv, 0) + .work (0) + .build (); + 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)); ASSERT_EQ (nullptr, latest2); - store->block.put (transaction, hash1, block); - store->block.put (transaction, hash2, block2); + 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); + ASSERT_EQ (*block, *latest3); auto latest4 (store->block.get (transaction, hash2)); ASSERT_NE (nullptr, latest4); - ASSERT_EQ (block2, *latest4); + ASSERT_EQ (*block2, *latest4); ASSERT_FALSE (*latest3 == *latest4); } @@ -223,19 +269,33 @@ TEST (block_store, add_receive) 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 ({}); + nano::block_builder builder; + auto block1 = builder + .open () + .source (0) + .representative (1) + .account (0) + .sign (nano::keypair ().prv, 0) + .work (0) + .build (); + block1->sideband_set ({}); auto transaction (store->tx_begin_write ()); - 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 ()); + store->block.put (transaction, block1->hash (), *block1); + auto block = builder + .receive () + .previous (block1->hash ()) + .source (1) + .sign (nano::keypair ().prv, 2) + .work (3) + .build (); + block->sideband_set ({}); + nano::block_hash hash1 (block->hash ()); auto latest1 (store->block.get (transaction, hash1)); ASSERT_EQ (nullptr, latest1); - store->block.put (transaction, hash1, block); + store->block.put (transaction, hash1, *block); auto latest2 (store->block.get (transaction, hash1)); ASSERT_NE (nullptr, latest2); - ASSERT_EQ (block, *latest2); + ASSERT_EQ (*block, *latest2); } TEST (block_store, add_pending) @@ -361,12 +421,20 @@ TEST (unchecked, simple) auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); nano::unchecked_map unchecked{ *store, false }; ASSERT_TRUE (!store->init_error ()); - std::shared_ptr block = std::make_shared (0, 1, 2, nano::keypair ().prv, 4, 5); + nano::block_builder builder; + auto block = builder + .send () + .previous (0) + .destination (1) + .balance (2) + .sign (nano::keypair ().prv, 4) + .work (5) + .build_shared (); // Asserts the block wasn't added yet to the unchecked table auto block_listing1 = unchecked.get (store->tx_begin_read (), block->previous ()); ASSERT_TRUE (block_listing1.empty ()); // Enqueues a block to be saved on the unchecked table - unchecked.put (block->previous (), block); + unchecked.put (block->previous (), nano::unchecked_info (block)); // Waits for the block to get written in the database auto check_block_is_listed = [&] (nano::transaction const & transaction_a, nano::block_hash const & block_hash_a) { return unchecked.get (transaction_a, block_hash_a).size () > 0; @@ -398,14 +466,22 @@ TEST (unchecked, multiple) auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); nano::unchecked_map unchecked{ *store, false }; ASSERT_TRUE (!store->init_error ()); - std::shared_ptr block = std::make_shared (4, 1, 2, nano::keypair ().prv, 4, 5); + nano::block_builder builder; + auto block = builder + .send () + .previous (4) + .destination (1) + .balance (2) + .sign (nano::keypair ().prv, 4) + .work (5) + .build_shared (); // Asserts the block wasn't added yet to the unchecked table auto block_listing1 = unchecked.get (store->tx_begin_read (), block->previous ()); ASSERT_TRUE (block_listing1.empty ()); // Enqueues the first block - unchecked.put (block->previous (), block); + unchecked.put (block->previous (), nano::unchecked_info (block)); // Enqueues a second block - unchecked.put (block->source (), block); + unchecked.put (block->source (), nano::unchecked_info (block)); auto check_block_is_listed = [&] (nano::transaction const & transaction_a, nano::block_hash const & block_hash_a) { return unchecked.get (transaction_a, block_hash_a).size () > 0; }; @@ -423,14 +499,22 @@ TEST (unchecked, double_put) auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); nano::unchecked_map unchecked{ *store, false }; ASSERT_TRUE (!store->init_error ()); - std::shared_ptr block = std::make_shared (4, 1, 2, nano::keypair ().prv, 4, 5); + nano::block_builder builder; + auto block = builder + .send () + .previous (4) + .destination (1) + .balance (2) + .sign (nano::keypair ().prv, 4) + .work (5) + .build_shared (); // Asserts the block wasn't added yet to the unchecked table auto block_listing1 = unchecked.get (store->tx_begin_read (), block->previous ()); ASSERT_TRUE (block_listing1.empty ()); // Enqueues the block to be saved in the unchecked table - unchecked.put (block->previous (), block); + unchecked.put (block->previous (), nano::unchecked_info (block)); // Enqueues the block again in an attempt to have it there twice - unchecked.put (block->previous (), block); + unchecked.put (block->previous (), nano::unchecked_info (block)); auto check_block_is_listed = [&] (nano::transaction const & transaction_a, nano::block_hash const & block_hash_a) { return unchecked.get (transaction_a, block_hash_a).size () > 0; }; @@ -450,18 +534,40 @@ TEST (unchecked, multiple_get) nano::unchecked_map unchecked{ *store, false }; ASSERT_TRUE (!store->init_error ()); // Instantiates three blocks - std::shared_ptr block1 = std::make_shared (4, 1, 2, nano::keypair ().prv, 4, 5); - std::shared_ptr block2 = std::make_shared (3, 1, 2, nano::keypair ().prv, 4, 5); - std::shared_ptr block3 = std::make_shared (5, 1, 2, nano::keypair ().prv, 4, 5); + nano::block_builder builder; + auto block1 = builder + .send () + .previous (4) + .destination (1) + .balance (2) + .sign (nano::keypair ().prv, 4) + .work (5) + .build_shared (); + auto block2 = builder + .send () + .previous (3) + .destination (1) + .balance (2) + .sign (nano::keypair ().prv, 4) + .work (5) + .build_shared (); + auto block3 = builder + .send () + .previous (5) + .destination (1) + .balance (2) + .sign (nano::keypair ().prv, 4) + .work (5) + .build_shared (); // Add the blocks' info to the unchecked table - unchecked.put (block1->previous (), block1); // unchecked1 - unchecked.put (block1->hash (), block1); // unchecked2 - unchecked.put (block2->previous (), block2); // unchecked3 - unchecked.put (block1->previous (), block2); // unchecked1 - unchecked.put (block1->hash (), block2); // unchecked2 - unchecked.put (block3->previous (), block3); - unchecked.put (block3->hash (), block3); // unchecked4 - unchecked.put (block1->previous (), block3); // unchecked1 + unchecked.put (block1->previous (), nano::unchecked_info (block1)); // unchecked1 + unchecked.put (block1->hash (), nano::unchecked_info (block1)); // unchecked2 + unchecked.put (block2->previous (), nano::unchecked_info (block2)); // unchecked3 + unchecked.put (block1->previous (), nano::unchecked_info (block2)); // unchecked1 + unchecked.put (block1->hash (), nano::unchecked_info (block2)); // unchecked2 + unchecked.put (block3->previous (), nano::unchecked_info (block3)); + unchecked.put (block3->hash (), nano::unchecked_info (block3)); // unchecked4 + unchecked.put (block1->previous (), nano::unchecked_info (block3)); // unchecked1 // count the number of blocks in the unchecked table by counting them one by one // we cannot trust the count() method if the backend is rocksdb @@ -530,11 +636,19 @@ TEST (block_store, one_block) nano::logger_mt logger; 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 ({}); + nano::block_builder builder; + auto block1 = builder + .open () + .source (0) + .representative (1) + .account (0) + .sign (nano::keypair ().prv, 0) + .work (0) + .build (); + 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) @@ -557,8 +671,23 @@ TEST (block_store, unchecked_begin_search) 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); - nano::send_block block2 (5, 6, 7, key0.prv, key0.pub, 8); + nano::block_builder builder; + auto block1 = builder + .send () + .previous (0) + .destination (1) + .balance (2) + .sign (key0.prv, key0.pub) + .work (3) + .build (); + auto block2 = builder + .send () + .previous (5) + .destination (6) + .balance (7) + .sign (key0.prv, key0.pub) + .work (8) + .build (); } TEST (block_store, frontier_retrieval) @@ -608,22 +737,37 @@ TEST (block_store, two_block) nano::logger_mt logger; 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 ({}); - block1.hashables.account = 1; + nano::block_builder builder; + auto block1 = builder + .open () + .source (0) + .representative (1) + .account (1) + .sign (nano::keypair ().prv, 0) + .work (0) + .build (); + block1->sideband_set ({}); + block1->hashables.account = 1; std::vector hashes; std::vector blocks; - hashes.push_back (block1.hash ()); - blocks.push_back (block1); + hashes.push_back (block1->hash ()); + blocks.push_back (*block1); auto transaction (store->tx_begin_write ()); - 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[0], *block1); + auto block2 = builder + .open () + .source (0) + .representative (1) + .account (2) + .sign (nano::keypair ().prv, 0) + .work (0) + .build (); + 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 ())); } TEST (block_store, two_account) @@ -781,14 +925,41 @@ TEST (block_store, roots) nano::logger_mt logger; 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 ()); - nano::change_block change_block (0, 1, nano::keypair ().prv, 3, 4); - ASSERT_EQ (change_block.hashables.previous, change_block.root ()); - nano::receive_block receive_block (0, 1, nano::keypair ().prv, 3, 4); - ASSERT_EQ (receive_block.hashables.previous, receive_block.root ()); - nano::open_block open_block (0, 1, 2, nano::keypair ().prv, 4, 5); - ASSERT_EQ (open_block.hashables.account, open_block.root ()); + nano::block_builder builder; + auto send_block = builder + .send () + .previous (0) + .destination (1) + .balance (2) + .sign (nano::keypair ().prv, 4) + .work (5) + .build (); + ASSERT_EQ (send_block->hashables.previous, send_block->root ()); + auto change_block = builder + .change () + .previous (0) + .representative (1) + .sign (nano::keypair ().prv, 3) + .work (4) + .build (); + ASSERT_EQ (change_block->hashables.previous, change_block->root ()); + auto receive_block = builder + .receive () + .previous (0) + .source (1) + .sign (nano::keypair ().prv, 3) + .work (4) + .build (); + ASSERT_EQ (receive_block->hashables.previous, receive_block->root ()); + auto open_block = builder + .open () + .source (0) + .representative (1) + .account (2) + .sign (nano::keypair ().prv, 4) + .work (5) + .build (); + ASSERT_EQ (open_block->hashables.account, open_block->root ()); } TEST (block_store, pending_exists) @@ -877,13 +1048,28 @@ TEST (block_store, block_replace) nano::logger_mt logger; 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 ({}); + nano::block_builder builder; + auto send1 = builder + .send () + .previous (0) + .destination (0) + .balance (0) + .sign (nano::keypair ().prv, 0) + .work (1) + .build (); + send1->sideband_set ({}); + auto send2 = builder + .send () + .previous (0) + .destination (0) + .balance (0) + .sign (nano::keypair ().prv, 0) + .work (2) + .build (); + send2->sideband_set ({}); auto transaction (store->tx_begin_write ()); - store->block.put (transaction, 0, send1); - store->block.put (transaction, 0, send2); + 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 ()); @@ -897,10 +1083,18 @@ TEST (block_store, block_count) { auto transaction (store->tx_begin_write ()); 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); + nano::block_builder builder; + auto block = builder + .open () + .source (0) + .representative (1) + .account (0) + .sign (nano::keypair ().prv, 0) + .work (0) + .build (); + block->sideband_set ({}); + auto hash1 (block->hash ()); + store->block.put (transaction, hash1, *block); } auto transaction (store->tx_begin_read ()); ASSERT_EQ (1, store->block.count (transaction)); @@ -953,9 +1147,17 @@ TEST (block_store, pruned_random) nano::logger_mt logger; 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 ()); + nano::block_builder builder; + auto block = builder + .open () + .source (0) + .representative (1) + .account (0) + .sign (nano::keypair ().prv, 0) + .work (0) + .build (); + block->sideband_set ({}); + auto hash1 (block->hash ()); { nano::ledger_cache ledger_cache; auto transaction (store->tx_begin_write ()); @@ -981,20 +1183,35 @@ namespace lmdb auto transaction (store.tx_begin_write ()); ASSERT_EQ (0, mdb_drop (store.env.tx (transaction), store.unchecked_store.unchecked_handle, 1)); ASSERT_EQ (0, mdb_dbi_open (store.env.tx (transaction), "unchecked", MDB_CREATE, &store.unchecked_store.unchecked_handle)); - std::shared_ptr send1 = std::make_shared (0, 0, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0); - std::shared_ptr send2 = std::make_shared (1, 0, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0); + nano::block_builder builder; + auto send1 = builder + .send () + .previous (0) + .destination (0) + .balance (0) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (0) + .build_shared (); + auto send2 = builder + .send () + .previous (1) + .destination (0) + .balance (0) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (0) + .build_shared (); ASSERT_NE (send1->hash (), send2->hash ()); - unchecked.put (send1->hash (), send1); - unchecked.put (send1->hash (), send2); + unchecked.put (send1->hash (), nano::unchecked_info (send1)); + unchecked.put (send1->hash (), nano::unchecked_info (send2)); ASSERT_EQ (0, mdb_drop (store.env.tx (transaction), store.unchecked_store.unchecked_handle, 0)); mdb_dbi_close (store.env, store.unchecked_store.unchecked_handle); ASSERT_EQ (0, mdb_dbi_open (store.env.tx (transaction), "unchecked", MDB_CREATE | MDB_DUPSORT, &store.unchecked_store.unchecked_handle)); - unchecked.put (send1->hash (), send1); - unchecked.put (send1->hash (), send2); + unchecked.put (send1->hash (), nano::unchecked_info (send1)); + unchecked.put (send1->hash (), nano::unchecked_info (send2)); ASSERT_EQ (0, mdb_drop (store.env.tx (transaction), store.unchecked_store.unchecked_handle, 1)); ASSERT_EQ (0, mdb_dbi_open (store.env.tx (transaction), "unchecked", MDB_CREATE | MDB_DUPSORT, &store.unchecked_store.unchecked_handle)); - unchecked.put (send1->hash (), send1); - unchecked.put (send1->hash (), send2); + unchecked.put (send1->hash (), nano::unchecked_info (send1)); + unchecked.put (send1->hash (), nano::unchecked_info (send2)); } } } @@ -1005,25 +1222,36 @@ TEST (block_store, state_block) auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_FALSE (store->init_error ()); nano::keypair key1; - nano::state_block block1 (1, nano::dev::genesis->hash (), 3, 4, 6, key1.prv, key1.pub, 7); - block1.sideband_set ({}); + nano::block_builder builder; + auto block1 = builder + .state () + .account (1) + .previous (nano::dev::genesis->hash ()) + .representative (3) + .balance (4) + .link (6) + .sign (key1.prv, key1.pub) + .work (7) + .build (); + + block1->sideband_set ({}); { nano::ledger_cache ledger_cache; auto transaction (store->tx_begin_write ()); store->initialize (transaction, ledger_cache, nano::dev::constants); - 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 ())); + 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 ())); ASSERT_NE (nullptr, block2); - ASSERT_EQ (block1, *block2); + ASSERT_EQ (*block1, *block2); } { auto transaction (store->tx_begin_write ()); 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)); @@ -1045,56 +1273,146 @@ TEST (mdb_block_store, sideband_height) ASSERT_FALSE (store.init_error ()); nano::stat stat; nano::ledger ledger (store, stat, nano::dev::constants); + nano::block_builder builder; auto transaction (store.tx_begin_write ()); store.initialize (transaction, ledger.cache, nano::dev::constants); 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::Gxrb_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 ())); - 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 ())); - 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::dev::constants.genesis_amount - nano::Gxrb_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::dev::constants.genesis_amount - 2 * nano::Gxrb_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::dev::constants.genesis_amount - 3 * nano::Gxrb_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::Gxrb_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::Gxrb_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::process_result::progress, ledger.process (transaction, epoch_open).code); - 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::Gxrb_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)); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, open).code); + auto send = builder + .send () + .previous (nano::dev::genesis->hash ()) + .destination (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send).code); + auto receive = builder + .receive () + .previous (send->hash ()) + .source (send->hash ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (send->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *receive).code); + auto change = builder + .change () + .previous (receive->hash ()) + .representative (0) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (receive->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *change).code); + auto state_send1 = builder + .state () + .account (nano::dev::genesis_key.pub) + .previous (change->hash ()) + .representative (0) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .link (key1.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (change->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *state_send1).code); + auto state_send2 = builder + .state () + .account (nano::dev::genesis_key.pub) + .previous (state_send1->hash ()) + .representative (0) + .balance (nano::dev::constants.genesis_amount - 2 * nano::Gxrb_ratio) + .link (key2.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (state_send1->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *state_send2).code); + auto state_send3 = builder + .state () + .account (nano::dev::genesis_key.pub) + .previous (state_send2->hash ()) + .representative (0) + .balance (nano::dev::constants.genesis_amount - 3 * nano::Gxrb_ratio) + .link (key3.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (state_send2->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *state_send3).code); + auto state_open = builder + .state () + .account (key1.pub) + .previous (0) + .representative (0) + .balance (nano::Gxrb_ratio) + .link (state_send1->hash ()) + .sign (key1.prv, key1.pub) + .work (*pool.generate (key1.pub)) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *state_open).code); + auto epoch = builder + .state () + .account (key1.pub) + .previous (state_open->hash ()) + .representative (0) + .balance (nano::Gxrb_ratio) + .link (ledger.epoch_link (nano::epoch::epoch_1)) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (state_open->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *epoch).code); + ASSERT_EQ (nano::epoch::epoch_1, store.block.version (transaction, epoch->hash ())); + auto epoch_open = builder + .state () + .account (key2.pub) + .previous (0) + .representative (0) + .balance (0) + .link (ledger.epoch_link (nano::epoch::epoch_1)) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (key2.pub)) + .build (); + 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 ())); + auto state_receive = builder + .state () + .account (key2.pub) + .previous (epoch_open->hash ()) + .representative (0) + .balance (nano::Gxrb_ratio) + .link (state_send2->hash ()) + .sign (key2.prv, key2.pub) + .work (*pool.generate (epoch_open->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *state_receive).code); + auto open = builder + .open () + .source (state_send3->hash ()) + .representative (nano::dev::genesis_key.pub) + .account (key3.pub) + .sign (key3.prv, key3.pub) + .work (*pool.generate (key3.pub)) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *open).code); 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); } @@ -1238,8 +1556,16 @@ TEST (block_store, pruned_blocks) ASSERT_TRUE (!store->init_error ()); nano::keypair key1; - nano::open_block block1 (0, 1, key1.pub, key1.prv, key1.pub, 0); - auto hash1 (block1.hash ()); + nano::block_builder builder; + auto block1 = builder + .open () + .source (0) + .representative (1) + .account (key1.pub) + .sign (key1.prv, key1.pub) + .work (0) + .build (); + auto hash1 (block1->hash ()); { auto transaction (store->tx_begin_write ()); @@ -1256,9 +1582,16 @@ TEST (block_store, pruned_blocks) 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); - block2.sideband_set ({}); - auto hash2 (block2.hash ()); + auto block2 = builder + .open () + .source (1) + .representative (2) + .account (key1.pub) + .sign (key1.prv, key1.pub) + .work (0) + .build (); + block2->sideband_set ({}); + auto hash2 (block2->hash ()); { auto transaction (store->tx_begin_write ()); store->pruned.put (transaction, hash2); @@ -1276,7 +1609,7 @@ TEST (block_store, pruned_blocks) 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 + 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)); @@ -1307,13 +1640,36 @@ namespace lmdb } // Extract confirmation height to a separate database auto path (nano::unique_path ()); + nano::block_builder builder; 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::Gxrb_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::Gxrb_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::Gxrb_ratio * 2, nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (epoch.hash ())); + auto send = builder + .send () + .previous (nano::dev::genesis->hash ()) + .destination (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); + auto epoch = builder + .state () + .account (nano::dev::genesis_key.pub) + .previous (send->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .link (nano::dev::network_params.ledger.epochs.link (nano::epoch::epoch_1)) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (send->hash ())) + .build (); + auto state_send = builder + .state () + .account (nano::dev::genesis_key.pub) + .previous (epoch->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 2) + .link (nano::dev::genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (epoch->hash ())) + .build (); { nano::logger_mt logger; nano::lmdb::store store (logger, path, nano::dev::constants); @@ -1340,35 +1696,35 @@ namespace lmdb ASSERT_FALSE ( mdb_dbi_open (store.env.tx (transaction), "state_blocks", MDB_CREATE, &store.block_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); + 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::dev::genesis->account ()); modify_account_info_to_v14 (store, transaction, nano::dev::genesis->account (), - confirmation_height_info.height, state_send.hash ()); + confirmation_height_info.height, state_send->hash ()); - store.pending.del (transaction, nano::pending_key (nano::dev::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.block_store.state_blocks_v1_handle); - write_sideband_v14 (store, transaction, epoch, store.block_store.state_blocks_v1_handle); + write_sideband_v14 (store, transaction, *state_send, store.block_store.state_blocks_v1_handle); + write_sideband_v14 (store, transaction, *epoch, store.block_store.state_blocks_v1_handle); write_block_w_sideband_v18 (store, store.block_store.open_blocks_handle, transaction, *nano::dev::genesis); - write_block_w_sideband_v18 (store, store.block_store.send_blocks_handle, transaction, send); + write_block_w_sideband_v18 (store, store.block_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_store.pending_v0_handle, - nano::mdb_val (nano::pending_key (nano::dev::genesis_key.pub, send.hash ())), + 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::Gxrb_ratio, nano::epoch::epoch_0)), 0)); ASSERT_FALSE (mdb_put (store.env.tx (transaction), store.pending_store.pending_v1_handle, - nano::mdb_val (nano::pending_key (nano::dev::genesis_key.pub, state_send.hash ())), + 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::Gxrb_ratio, nano::epoch::epoch_1)), @@ -1412,25 +1768,25 @@ namespace lmdb auto error_get_accounts_v1 (mdb_get (store.env.tx (transaction), store.account_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_store.pending_v1_handle, 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_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.block_store.state_blocks_v1_handle, nano::mdb_val (state_send.hash ()), + mdb_get (store.env.tx (transaction), store.block_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 ()), + 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); @@ -1493,9 +1849,37 @@ namespace lmdb return; } 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::Gxrb_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::Gxrb_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::Gxrb_ratio - 2, nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (block2.hash ())); + nano::block_builder builder; + auto block1 = builder + .state () + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .link (nano::dev::genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); + auto block2 = builder + .state () + .account (nano::dev::genesis_key.pub) + .previous (block1->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio - 1) + .link (nano::dev::genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (block1->hash ())) + .build (); + auto block3 = builder + .state () + .account (nano::dev::genesis_key.pub) + .previous (block2->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio - 2) + .link (nano::dev::genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (block2->hash ())) + .build (); auto code = [&block1, &block2, &block3] (auto confirmation_height, nano::block_hash const & expected_cemented_frontier) { auto path (nano::unique_path ()); @@ -1507,17 +1891,17 @@ namespace lmdb nano::ledger ledger (store, stats, nano::dev::constants); auto transaction (store.tx_begin_write ()); store.initialize (transaction, ledger.cache, nano::dev::constants); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block1).code); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block2).code); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block3).code); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *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::dev::genesis->account (), confirmation_height); ASSERT_FALSE (mdb_dbi_open (store.env.tx (transaction), "open", MDB_CREATE, &store.block_store.open_blocks_handle)); write_block_w_sideband_v18 (store, store.block_store.open_blocks_handle, transaction, *nano::dev::genesis); ASSERT_FALSE (mdb_dbi_open (store.env.tx (transaction), "state_blocks", MDB_CREATE, &store.block_store.state_blocks_handle)); - write_block_w_sideband_v18 (store, store.block_store.state_blocks_handle, transaction, block1); - write_block_w_sideband_v18 (store, store.block_store.state_blocks_handle, transaction, block2); - write_block_w_sideband_v18 (store, store.block_store.state_blocks_handle, transaction, block3); + write_block_w_sideband_v18 (store, store.block_store.state_blocks_handle, transaction, *block1); + write_block_w_sideband_v18 (store, store.block_store.state_blocks_handle, transaction, *block2); + write_block_w_sideband_v18 (store, store.block_store.state_blocks_handle, transaction, *block3); // Lower the database to the previous version store.version.put (transaction, 16); @@ -1542,9 +1926,9 @@ namespace lmdb code (0, nano::block_hash (0)); code (1, nano::dev::genesis->hash ()); - code (2, block1.hash ()); - code (3, block2.hash ()); - code (4, block3.hash ()); + code (2, block1->hash ()); + code (3, block2->hash ()); + code (4, block3->hash ()); } TEST (mdb_block_store, upgrade_v17_v18) @@ -1555,22 +1939,129 @@ namespace lmdb return; } auto path (nano::unique_path ()); + nano::block_builder builder; nano::keypair key1; nano::keypair key2; nano::keypair key3; 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::Gxrb_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::Gxrb_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::Gxrb_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::dev::constants.genesis_amount - nano::Gxrb_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::Gxrb_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, nano::dev::network_params.ledger.epochs.link (nano::epoch::epoch_2), key2.prv, key2.pub, *pool.generate (state_open.hash ())); + auto send_zero = builder + .send () + .previous (nano::dev::genesis->hash ()) + .destination (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); + auto state_receive_zero = builder + .state () + .account (nano::dev::genesis_key.pub) + .previous (send_zero->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount) + .link (send_zero->hash ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (send_zero->hash ())) + .build (); + auto epoch = builder + .state () + .account (nano::dev::genesis_key.pub) + .previous (state_receive_zero->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount) + .link (nano::dev::network_params.ledger.epochs.link (nano::epoch::epoch_1)) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (state_receive_zero->hash ())) + .build (); + auto state_send = builder + .state () + .account (nano::dev::genesis_key.pub) + .previous (epoch->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .link (nano::dev::genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (epoch->hash ())) + .build (); + auto state_receive = builder + .state () + .account (nano::dev::genesis_key.pub) + .previous (state_send->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount) + .link (state_send->hash ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (state_send->hash ())) + .build (); + auto state_change = builder + .state () + .account (nano::dev::genesis_key.pub) + .previous (state_receive->hash ()) + .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) + .work (*pool.generate (state_receive->hash ())) + .build (); + auto state_send_change = builder + .state () + .account (nano::dev::genesis_key.pub) + .previous (state_change->hash ()) + .representative (key1.pub) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .link (key1.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (state_change->hash ())) + .build (); + auto epoch_first = builder + .state () + .account (key1.pub) + .previous (0) + .representative (0) + .balance (0) + .link (nano::dev::network_params.ledger.epochs.link (nano::epoch::epoch_2)) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (key1.pub)) + .build (); + auto state_receive2 = builder + .state () + .account (key1.pub) + .previous (epoch_first->hash ()) + .representative (key1.pub) + .balance (nano::Gxrb_ratio) + .link (state_send_change->hash ()) + .sign (key1.prv, key1.pub) + .work (*pool.generate (epoch_first->hash ())) + .build (); + auto state_send2 = builder + .state () + .account (nano::dev::genesis_key.pub) + .previous (state_send_change->hash ()) + .representative (key1.pub) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 2) + .link (key2.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (state_send_change->hash ())) + .build (); + auto state_open = builder + .state () + .account (key2.pub) + .previous (0) + .representative (key2.pub) + .balance (nano::Gxrb_ratio) + .link (state_send2->hash ()) + .sign (key2.prv, key2.pub) + .work (*pool.generate (key2.pub)) + .build (); + auto state_send_epoch_link = builder + .state () + .account (key2.pub) + .previous (state_open->hash ()) + .representative (key2.pub) + .balance (0) + .link (nano::dev::network_params.ledger.epochs.link (nano::epoch::epoch_2)) + .sign (key2.prv, key2.pub) + .work (*pool.generate (state_open->hash ())) + .build (); { nano::logger_mt logger; nano::lmdb::store store (logger, path, nano::dev::constants); @@ -1578,18 +2069,18 @@ namespace lmdb nano::stat stats; nano::ledger ledger (store, stats, nano::dev::constants); store.initialize (transaction, ledger.cache, nano::dev::constants); - 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); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, state_send).code); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, state_receive).code); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, state_change).code); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, state_send_change).code); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, epoch_first).code); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, state_receive2).code); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, state_send2).code); - 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_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); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *state_send).code); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *state_receive).code); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *state_change).code); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *state_send_change).code); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *epoch_first).code); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *state_receive2).code); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *state_send2).code); + 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.block_store.open_blocks_handle)); ASSERT_FALSE (mdb_dbi_open (store.env.tx (transaction), "send", MDB_CREATE, &store.block_store.send_blocks_handle)); @@ -1598,30 +2089,30 @@ namespace lmdb // Downgrade the store store.version.put (transaction, 17); - write_block_w_sideband_v18 (store, store.block_store.state_blocks_handle, transaction, state_receive); - write_block_w_sideband_v18 (store, store.block_store.state_blocks_handle, transaction, epoch_first); - write_block_w_sideband_v18 (store, store.block_store.state_blocks_handle, transaction, state_send2); - write_block_w_sideband_v18 (store, store.block_store.state_blocks_handle, transaction, state_send_epoch_link); + write_block_w_sideband_v18 (store, store.block_store.state_blocks_handle, transaction, *state_receive); + write_block_w_sideband_v18 (store, store.block_store.state_blocks_handle, transaction, *epoch_first); + write_block_w_sideband_v18 (store, store.block_store.state_blocks_handle, transaction, *state_send2); + write_block_w_sideband_v18 (store, store.block_store.state_blocks_handle, transaction, *state_send_epoch_link); write_block_w_sideband_v18 (store, store.block_store.open_blocks_handle, transaction, *nano::dev::genesis); - write_block_w_sideband_v18 (store, store.block_store.send_blocks_handle, transaction, send_zero); + write_block_w_sideband_v18 (store, store.block_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 - write_sideband_v15 (store, transaction, state_receive_zero); - write_sideband_v15 (store, transaction, epoch); - write_sideband_v15 (store, transaction, state_send); - write_sideband_v15 (store, transaction, state_change); - write_sideband_v15 (store, transaction, state_send_change); - 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 ()); + write_sideband_v15 (store, transaction, *state_receive_zero); + write_sideband_v15 (store, transaction, *epoch); + write_sideband_v15 (store, transaction, *state_send); + write_sideband_v15 (store, transaction, *state_change); + write_sideband_v15 (store, transaction, *state_send_change); + 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 ()); } // Now do the upgrade @@ -1632,13 +2123,13 @@ namespace lmdb // 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.block_store.blocks_handle, nano::mdb_val (state_send.hash ()), value)); + ASSERT_FALSE (mdb_get (store.env.tx (transaction), store.block_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); @@ -1648,7 +2139,7 @@ namespace lmdb } { // 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); @@ -1657,7 +2148,7 @@ namespace lmdb } { // 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); @@ -1666,7 +2157,7 @@ namespace lmdb } { // 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); @@ -1675,7 +2166,7 @@ namespace lmdb } { // 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); @@ -1684,7 +2175,7 @@ namespace lmdb } { // 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); @@ -1693,7 +2184,7 @@ namespace lmdb } { // 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); @@ -1702,7 +2193,7 @@ namespace lmdb } { // 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); @@ -1711,7 +2202,7 @@ namespace lmdb } { // 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); @@ -1720,7 +2211,7 @@ namespace lmdb } { // 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); @@ -1729,7 +2220,7 @@ namespace lmdb } { // 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); @@ -1738,7 +2229,7 @@ namespace lmdb } { // 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); @@ -1758,14 +2249,60 @@ namespace lmdb } auto path (nano::unique_path ()); nano::keypair key1; + nano::block_builder builder; 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::Gxrb_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::Gxrb_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::Gxrb_ratio, state_send.hash (), key1.prv, key1.pub, *pool.generate (key1.pub)); - + auto send = builder + .send () + .previous (nano::dev::genesis->hash ()) + .destination (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); + auto receive = builder + .receive () + .previous (send->hash ()) + .source (send->hash ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (send->hash ())) + .build (); + auto change = builder + .change () + .previous (receive->hash ()) + .representative (0) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (receive->hash ())) + .build (); + auto state_epoch = builder + .state () + .account (nano::dev::genesis_key.pub) + .previous (change->hash ()) + .representative (0) + .balance (nano::dev::constants.genesis_amount) + .link (nano::dev::network_params.ledger.epochs.link (nano::epoch::epoch_1)) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (change->hash ())) + .build (); + auto state_send = builder + .state () + .account (nano::dev::genesis_key.pub) + .previous (state_epoch->hash ()) + .representative (0) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .link (key1.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (state_epoch->hash ())) + .build (); + auto state_open = builder + .state () + .account (key1.pub) + .previous (0) + .representative (0) + .balance (nano::Gxrb_ratio) + .link (state_send->hash ()) + .sign (key1.prv, key1.pub) + .work (*pool.generate (key1.pub)) + .build (); { nano::logger_mt logger; nano::lmdb::store store (logger, path, nano::dev::constants); @@ -1774,12 +2311,12 @@ namespace lmdb auto transaction (store.tx_begin_write ()); store.initialize (transaction, ledger.cache, nano::dev::constants); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send).code); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, receive).code); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, change).code); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, state_epoch).code); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, state_send).code); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, state_open).code); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send).code); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *receive).code); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *change).code); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *state_epoch).code); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *state_send).code); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *state_open).code); // These tables need to be re-opened and populated so that an upgrade can be done auto txn = store.env.tx (transaction); @@ -1791,12 +2328,12 @@ namespace lmdb // Modify blocks back to the old tables write_block_w_sideband_v18 (store, store.block_store.open_blocks_handle, transaction, *nano::dev::genesis); - write_block_w_sideband_v18 (store, store.block_store.send_blocks_handle, transaction, send); - write_block_w_sideband_v18 (store, store.block_store.receive_blocks_handle, transaction, receive); - write_block_w_sideband_v18 (store, store.block_store.change_blocks_handle, transaction, change); - write_block_w_sideband_v18 (store, store.block_store.state_blocks_handle, transaction, state_epoch); - write_block_w_sideband_v18 (store, store.block_store.state_blocks_handle, transaction, state_send); - write_block_w_sideband_v18 (store, store.block_store.state_blocks_handle, transaction, state_open); + write_block_w_sideband_v18 (store, store.block_store.send_blocks_handle, transaction, *send); + write_block_w_sideband_v18 (store, store.block_store.receive_blocks_handle, transaction, *receive); + write_block_w_sideband_v18 (store, store.block_store.change_blocks_handle, transaction, *change); + write_block_w_sideband_v18 (store, store.block_store.state_blocks_handle, transaction, *state_epoch); + write_block_w_sideband_v18 (store, store.block_store.state_blocks_handle, transaction, *state_send); + write_block_w_sideband_v18 (store, store.block_store.state_blocks_handle, transaction, *state_open); store.version.put (transaction, 18); } @@ -1815,21 +2352,21 @@ namespace lmdb ASSERT_EQ (store.block_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, 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 ())); + 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); @@ -2048,9 +2585,17 @@ TEST (block_store, reset_renew_existing_transaction) ASSERT_TRUE (!store->init_error ()); nano::keypair key1; - nano::open_block block (0, 1, 1, nano::keypair ().prv, 0, 0); - block.sideband_set ({}); - auto hash1 (block.hash ()); + nano::block_builder builder; + auto block = builder + .open () + .source (0) + .representative (1) + .account (1) + .sign (nano::keypair ().prv, 0) + .work (0) + .build (); + block->sideband_set ({}); + auto hash1 (block->hash ()); auto read_transaction = store->tx_begin_read (); // Block shouldn't exist yet @@ -2063,7 +2608,7 @@ 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 (); @@ -2107,9 +2652,17 @@ TEST (rocksdb_block_store, tombstone_count) auto store = std::make_unique (logger, nano::unique_path (), nano::dev::constants); nano::unchecked_map unchecked{ *store, false }; ASSERT_TRUE (!store->init_error ()); - std::shared_ptr block = std::make_shared (0, 1, 2, nano::keypair ().prv, 4, 5); + nano::block_builder builder; + auto block = builder + .send () + .previous (0) + .destination (1) + .balance (2) + .sign (nano::keypair ().prv, 4) + .work (5) + .build_shared (); // Enqueues a block to be saved in the database - unchecked.put (block->previous (), block); + unchecked.put (block->previous (), nano::unchecked_info (block)); auto check_block_is_listed = [&] (nano::transaction const & transaction_a, nano::block_hash const & block_hash_a) { return unchecked.get (transaction_a, block_hash_a).size () > 0; }; diff --git a/nano/core_test/bootstrap.cpp b/nano/core_test/bootstrap.cpp index 8ef2d94426..51dec034c8 100644 --- a/nano/core_test/bootstrap.cpp +++ b/nano/core_test/bootstrap.cpp @@ -55,14 +55,22 @@ TEST (bulk_pull, end_not_owned) 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; - open.hashables.source = latest; - open.refresh (); - 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); + nano::block_builder builder; + auto open = builder + .open () + .source (0) + .representative (1) + .account (2) + .sign (nano::keypair ().prv, 4) + .work (5) + .build (); + open->hashables.account = key2.pub; + open->hashables.representative = key2.pub; + open->hashables.source = latest; + open->refresh (); + 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 (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; @@ -140,9 +148,23 @@ TEST (bulk_pull, count_limit) nano::system system (1); auto node0 (system.nodes[0]); - 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)))); + nano::block_builder builder; + auto send1 = builder + .send () + .previous (node0->latest (nano::dev::genesis_key.pub)) + .destination (nano::dev::genesis_key.pub) + .balance (1) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (node0->latest (nano::dev::genesis_key.pub))) + .build_shared (); 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 = builder + .receive () + .previous (send1->hash ()) + .source (send1->hash ()) + .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, node0->process (*receive1).code); auto connection (std::make_shared (std::make_shared (*node0, nano::socket::endpoint_type_t::server), node0)); @@ -320,13 +342,41 @@ 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)))); + nano::block_builder builder; + auto send1 = builder + .send () + .previous (node0->latest (nano::dev::genesis_key.pub)) + .destination (key.pub) + .balance (0) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (node0->latest (nano::dev::genesis_key.pub))) + .build_shared (); 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))); + auto open = builder + .open () + .source (send1->hash ()) + .representative (1) + .account (key.pub) + .sign (key.prv, key.pub) + .work (*system.work.generate (key.pub)) + .build_shared (); 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 = builder + .send () + .previous (open->hash ()) + .destination (nano::dev::genesis_key.pub) + .balance (std::numeric_limits::max () - 100) + .sign (key.prv, key.pub) + .work (*system.work.generate (open->hash ())) + .build_shared (); 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 = builder + .receive () + .previous (send1->hash ()) + .source (send2->hash ()) + .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, 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 ()); @@ -394,13 +444,41 @@ TEST (bootstrap_processor, DISABLED_push_diamond) auto wallet1 (node1->wallets.create (100)); 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)))); + nano::block_builder builder; + auto send1 = builder + .send () + .previous (node0->latest (nano::dev::genesis_key.pub)) + .destination (key.pub) + .balance (0) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (node0->latest (nano::dev::genesis_key.pub))) + .build_shared (); 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))); + auto open = builder + .open () + .source (send1->hash ()) + .representative (1) + .account (key.pub) + .sign (key.prv, key.pub) + .work (*system.work.generate (key.pub)) + .build_shared (); 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 = builder + .send () + .previous (open->hash ()) + .destination (nano::dev::genesis_key.pub) + .balance (std::numeric_limits::max () - 100) + .sign (key.prv, key.pub) + .work (*system.work.generate (open->hash ())) + .build_shared (); 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 = builder + .receive () + .previous (send1->hash ()) + .source (send2->hash ()) + .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 (*receive).code); node1->bootstrap_initiator.bootstrap (node0->network.endpoint (), false); ASSERT_TIMELY (10s, node0->balance (nano::dev::genesis_key.pub) == 100); @@ -426,17 +504,45 @@ TEST (bootstrap_processor, DISABLED_push_diamond_pruning) 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))); + nano::block_builder builder; + auto send1 = builder + .send () + .previous (latest) + .destination (key.pub) + .balance (0) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (latest)) + .build_shared (); 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))); + auto open = builder + .open () + .source (send1->hash ()) + .representative (1) + .account (key.pub) + .sign (key.prv, key.pub) + .work (*system.work.generate (key.pub)) + .build_shared (); 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::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 = builder + .send () + .previous (open->hash ()) + .destination (nano::dev::genesis_key.pub) + .balance (std::numeric_limits::max () - 100) + .sign (key.prv, key.pub) + .work (*system.work.generate (open->hash ())) + .build_shared (); 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 = builder + .receive () + .previous (send1->hash ()) + .source (send2->hash ()) + .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 (*receive).code); { auto transaction (node1->store.tx_begin_write ()); @@ -879,9 +985,10 @@ TEST (bootstrap_processor, DISABLED_lazy_unclear_state_link) nano::keypair key; // Generating test chain - nano::state_block_builder builder; + nano::block_builder builder; auto send1 = builder + .state () .account (nano::dev::genesis_key.pub) .previous (nano::dev::genesis->hash ()) .representative (nano::dev::genesis_key.pub) @@ -892,7 +999,7 @@ TEST (bootstrap_processor, DISABLED_lazy_unclear_state_link) .build_shared (); ASSERT_EQ (nano::process_result::progress, node1->process (*send1).code); auto send2 = builder - .make_block () + .state () .account (nano::dev::genesis_key.pub) .previous (send1->hash ()) .representative (nano::dev::genesis_key.pub) @@ -902,10 +1009,17 @@ TEST (bootstrap_processor, DISABLED_lazy_unclear_state_link) .work (*system.work.generate (send1->hash ())) .build_shared (); ASSERT_EQ (nano::process_result::progress, node1->process (*send2).code); - auto open (std::make_shared (send1->hash (), key.pub, key.pub, key.prv, key.pub, *system.work.generate (key.pub))); + auto open = builder + .open () + .source (send1->hash ()) + .representative (key.pub) + .account (key.pub) + .sign (key.prv, key.pub) + .work (*system.work.generate (key.pub)) + .build_shared (); ASSERT_EQ (nano::process_result::progress, node1->process (*open).code); auto receive = builder - .make_block () + .state () .account (key.pub) .previous (open->hash ()) .representative (key.pub) @@ -940,9 +1054,10 @@ TEST (bootstrap_processor, lazy_unclear_state_link_not_existing) nano::keypair key, key2; // Generating test chain - nano::state_block_builder builder; + nano::block_builder builder; auto send1 = builder + .state () .account (nano::dev::genesis_key.pub) .previous (nano::dev::genesis->hash ()) .representative (nano::dev::genesis_key.pub) @@ -952,10 +1067,17 @@ TEST (bootstrap_processor, lazy_unclear_state_link_not_existing) .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))); + auto open = builder + .open () + .source (send1->hash ()) + .representative (key.pub) + .account (key.pub) + .sign (key.prv, key.pub) + .work (*system.work.generate (key.pub)) + .build_shared (); ASSERT_EQ (nano::process_result::progress, node1->process (*open).code); auto send2 = builder - .make_block () + .state () .account (key.pub) .previous (open->hash ()) .representative (key.pub) @@ -990,9 +1112,10 @@ TEST (bootstrap_processor, DISABLED_lazy_destinations) nano::keypair key1, key2; // Generating test chain - nano::state_block_builder builder; + nano::block_builder builder; auto send1 = builder + .state () .account (nano::dev::genesis_key.pub) .previous (nano::dev::genesis->hash ()) .representative (nano::dev::genesis_key.pub) @@ -1003,7 +1126,7 @@ TEST (bootstrap_processor, DISABLED_lazy_destinations) .build_shared (); ASSERT_EQ (nano::process_result::progress, node1->process (*send1).code); auto send2 = builder - .make_block () + .state () .account (nano::dev::genesis_key.pub) .previous (send1->hash ()) .representative (nano::dev::genesis_key.pub) @@ -1013,10 +1136,17 @@ TEST (bootstrap_processor, DISABLED_lazy_destinations) .work (*system.work.generate (send1->hash ())) .build_shared (); ASSERT_EQ (nano::process_result::progress, node1->process (*send2).code); - auto open (std::make_shared (send1->hash (), key1.pub, key1.pub, key1.prv, key1.pub, *system.work.generate (key1.pub))); + auto open = builder + .open () + .source (send1->hash ()) + .representative (key1.pub) + .account (key1.pub) + .sign (key1.prv, key1.pub) + .work (*system.work.generate (key1.pub)) + .build_shared (); ASSERT_EQ (nano::process_result::progress, node1->process (*open).code); auto state_open = builder - .make_block () + .state () .account (key2.pub) .previous (0) .representative (key2.pub) @@ -1053,9 +1183,10 @@ TEST (bootstrap_processor, lazy_pruning_missing_block) nano::keypair key1, key2; // Generating test chain - nano::state_block_builder builder; + nano::block_builder builder; auto send1 = builder + .state () .account (nano::dev::genesis_key.pub) .previous (nano::dev::genesis->hash ()) .representative (nano::dev::genesis_key.pub) @@ -1066,7 +1197,7 @@ TEST (bootstrap_processor, lazy_pruning_missing_block) .build_shared (); node1->process_active (send1); auto send2 = builder - .make_block () + .state () .account (nano::dev::genesis_key.pub) .previous (send1->hash ()) .representative (nano::dev::genesis_key.pub) @@ -1076,10 +1207,17 @@ TEST (bootstrap_processor, lazy_pruning_missing_block) .work (*system.work.generate (send1->hash ())) .build_shared (); node1->process_active (send2); - auto open (std::make_shared (send1->hash (), key1.pub, key1.pub, key1.prv, key1.pub, *system.work.generate (key1.pub))); + auto open = builder + .open () + .source (send1->hash ()) + .representative (key1.pub) + .account (key1.pub) + .sign (key1.prv, key1.pub) + .work (*system.work.generate (key1.pub)) + .build_shared (); node1->process_active (open); auto state_open = builder - .make_block () + .state () .account (key2.pub) .previous (0) .representative (key2.pub) diff --git a/nano/core_test/confirmation_height.cpp b/nano/core_test/confirmation_height.cpp index 6fbadd618a..44e5607e31 100644 --- a/nano/core_test/confirmation_height.cpp +++ b/nano/core_test/confirmation_height.cpp @@ -40,7 +40,17 @@ TEST (confirmation_height, single) 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))); + nano::block_builder builder; + auto send1 = builder + .state () + .account (nano::dev::genesis_key.pub) + .previous (latest1) + .representative (nano::dev::genesis_key.pub) + .balance (amount - 100) + .link (key1.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (latest1)) + .build_shared (); // Check confirmation heights before, should be uninitialized (1 for genesis). nano::confirmation_height_info confirmation_height_info; @@ -91,43 +101,119 @@ TEST (confirmation_height, multiple_accounts) nano::keypair key2; nano::keypair key3; nano::block_hash latest1 (system.nodes[0]->latest (nano::dev::genesis_key.pub)); + nano::block_builder builder; // 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 ())); + auto send1 = builder + .send () + .previous (latest1) + .destination (key1.pub) + .balance (node->online_reps.delta () + 300) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (latest1)) + .build (); + auto send2 = builder + .send () + .previous (send1->hash ()) + .destination (key2.pub) + .balance (node->online_reps.delta () + 200) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (send1->hash ())) + .build (); + auto send3 = builder + .send () + .previous (send2->hash ()) + .destination (key3.pub) + .balance (node->online_reps.delta () + 100) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (send2->hash ())) + .build (); // Open all accounts - 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)); + auto open1 = builder + .open () + .source (send1->hash ()) + .representative (nano::dev::genesis->account ()) + .account (key1.pub) + .sign (key1.prv, key1.pub) + .work (*system.work.generate (key1.pub)) + .build (); + auto open2 = builder + .open () + .source (send2->hash ()) + .representative (nano::dev::genesis->account ()) + .account (key2.pub) + .sign (key2.prv, key2.pub) + .work (*system.work.generate (key2.pub)) + .build (); + auto open3 = builder + .open () + .source (send3->hash ()) + .representative (nano::dev::genesis->account ()) + .account (key3.pub) + .sign (key3.prv, key3.pub) + .work (*system.work.generate (key3.pub)) + .build (); // 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 ())); - nano::send_block send5 (send4.hash (), key2.pub, 10, key1.prv, key1.pub, *system.work.generate (send4.hash ())); - - nano::receive_block receive1 (open2.hash (), send4.hash (), key2.prv, key2.pub, *system.work.generate (open2.hash ())); - nano::send_block send6 (receive1.hash (), key3.pub, 10, key2.prv, key2.pub, *system.work.generate (receive1.hash ())); - nano::receive_block receive2 (send6.hash (), send5.hash (), key2.prv, key2.pub, *system.work.generate (send6.hash ())); + auto send4 = builder + .send () + .previous (open1->hash ()) + .destination (key2.pub) + .balance (50) + .sign (key1.prv, key1.pub) + .work (*system.work.generate (open1->hash ())) + .build (); + auto send5 = builder + .send () + .previous (send4->hash ()) + .destination (key2.pub) + .balance (10) + .sign (key1.prv, key1.pub) + .work (*system.work.generate (send4->hash ())) + .build (); + + auto receive1 = builder + .receive () + .previous (open2->hash ()) + .source (send4->hash ()) + .sign (key2.prv, key2.pub) + .work (*system.work.generate (open2->hash ())) + .build (); + auto send6 = builder + .send () + .previous (receive1->hash ()) + .destination (key3.pub) + .balance (10) + .sign (key2.prv, key2.pub) + .work (*system.work.generate (receive1->hash ())) + .build (); + auto receive2 = builder + .receive () + .previous (send6->hash ()) + .source (send5->hash ()) + .sign (key2.prv, key2.pub) + .work (*system.work.generate (send6->hash ())) + .build (); add_callback_stats (*node); { auto transaction = node->store.tx_begin_write (); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send1).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send2).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send3).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send1).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send2).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send3).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, open1).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, open2).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, open3).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *open1).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *open2).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *open3).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send4).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send5).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send4).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send5).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, receive1).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send6).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, receive2).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *receive1).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send6).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *receive2).code); // 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. @@ -147,7 +233,13 @@ TEST (confirmation_height, multiple_accounts) } // The nodes process a live receive which propagates across to all accounts - auto receive3 = std::make_shared (open3.hash (), send6.hash (), key3.prv, key3.pub, *system.work.generate (open3.hash ())); + auto receive3 = builder + .receive () + .previous (open3->hash ()) + .source (send6->hash ()) + .sign (key3.prv, key3.pub) + .work (*system.work.generate (open3->hash ())) + .build_shared (); node->process_active (receive3); node->block_processor.flush (); node->block_confirm (receive3); @@ -165,17 +257,17 @@ TEST (confirmation_height, multiple_accounts) 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 (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_EQ (2, confirmation_height_info.height); - ASSERT_EQ (send4.hash (), confirmation_height_info.frontier); + 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_EQ (3, confirmation_height_info.height); - ASSERT_EQ (send6.hash (), confirmation_height_info.frontier); + 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)); @@ -201,8 +293,8 @@ TEST (confirmation_height, multiple_accounts) 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 ())); - ASSERT_TRUE (node->ledger.rollback (transaction, send2.hash ())); + ASSERT_TRUE (node->ledger.rollback (transaction, open1->hash ())); + ASSERT_TRUE (node->ledger.rollback (transaction, send2->hash ())); } ASSERT_EQ (10, node->stats.count (nano::stat::type::confirmation_height, nano::stat::detail::blocks_confirmed, nano::stat::dir::in)); ASSERT_EQ (10, node->stats.count (nano::stat::type::confirmation_height, get_stats_detail (mode_a), nano::stat::dir::in)); @@ -224,19 +316,66 @@ TEST (confirmation_height, gap_bootstrap) node_flags.confirmation_height_processor_mode = mode_a; auto & node1 = *system.add_node (node_flags); nano::keypair destination{}; - auto send1 = std::make_shared (nano::dev::genesis->account (), nano::dev::genesis->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::Gxrb_ratio, destination.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0); + nano::block_builder builder; + auto send1 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .link (destination.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (0) + .build_shared (); node1.work_generate_blocking (*send1); - auto send2 = std::make_shared (nano::dev::genesis->account (), send1->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - 2 * nano::Gxrb_ratio, destination.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0); + auto send2 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (send1->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - 2 * nano::Gxrb_ratio) + .link (destination.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (0) + .build_shared (); node1.work_generate_blocking (*send2); - auto send3 = std::make_shared (nano::dev::genesis->account (), send2->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - 3 * nano::Gxrb_ratio, destination.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0); + auto send3 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (send2->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - 3 * nano::Gxrb_ratio) + .link (destination.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (0) + .build_shared (); node1.work_generate_blocking (*send3); - auto open1 = std::make_shared (send1->hash (), destination.pub, destination.pub, destination.prv, destination.pub, 0); + auto open1 = builder + .open () + .source (send1->hash ()) + .representative (destination.pub) + .account (destination.pub) + .sign (destination.prv, destination.pub) + .work (0) + .build_shared (); node1.work_generate_blocking (*open1); // Receive - auto receive1 = std::make_shared (open1->hash (), send2->hash (), destination.prv, destination.pub, 0); + auto receive1 = builder + .receive () + .previous (open1->hash ()) + .source (send2->hash ()) + .sign (destination.prv, destination.pub) + .work (0) + .build_shared (); node1.work_generate_blocking (*receive1); - auto receive2 = std::make_shared (receive1->hash (), send3->hash (), destination.prv, destination.pub, 0); + auto receive2 = builder + .receive () + .previous (receive1->hash ()) + .source (send3->hash ()) + .sign (destination.prv, destination.pub) + .work (0) + .build_shared (); node1.work_generate_blocking (*receive2); node1.block_processor.add (send1); @@ -310,18 +449,65 @@ TEST (confirmation_height, gap_live) system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); system.wallet (1)->insert_adhoc (destination.prv); - 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); + nano::block_builder builder; + auto send1 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - 1) + .link (destination.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (0) + .build_shared (); node->work_generate_blocking (*send1); - 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); + auto send2 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (send1->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - 2) + .link (destination.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (0) + .build_shared (); node->work_generate_blocking (*send2); - 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); + auto send3 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (send2->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - 3) + .link (destination.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (0) + .build_shared (); node->work_generate_blocking (*send3); - auto open1 = std::make_shared (send1->hash (), destination.pub, destination.pub, destination.prv, destination.pub, 0); + auto open1 = builder + .open () + .source (send1->hash ()) + .representative (destination.pub) + .account (destination.pub) + .sign (destination.prv, destination.pub) + .work (0) + .build_shared (); node->work_generate_blocking (*open1); - auto receive1 = std::make_shared (open1->hash (), send2->hash (), destination.prv, destination.pub, 0); + auto receive1 = builder + .receive () + .previous (open1->hash ()) + .source (send2->hash ()) + .sign (destination.prv, destination.pub) + .work (0) + .build_shared (); node->work_generate_blocking (*receive1); - auto receive2 = std::make_shared (receive1->hash (), send3->hash (), destination.prv, destination.pub, 0); + auto receive2 = builder + .receive () + .previous (receive1->hash ()) + .source (send3->hash ()) + .sign (destination.prv, destination.pub) + .work (0) + .build_shared (); node->work_generate_blocking (*receive2); node->block_processor.add (send1); @@ -393,38 +579,109 @@ TEST (confirmation_height, send_receive_between_2_accounts) nano::keypair key1; 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::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::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::block_builder builder; + auto send1 = builder + .send () + .previous (latest) + .destination (key1.pub) + .balance (node->online_reps.delta () + 2) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (latest)) + .build (); + auto open1 = builder + .open () + .source (send1->hash ()) + .representative (nano::dev::genesis->account ()) + .account (key1.pub) + .sign (key1.prv, key1.pub) + .work (*system.work.generate (key1.pub)) + .build (); + auto send2 = builder + .send () + .previous (open1->hash ()) + .destination (nano::dev::genesis->account ()) + .balance (1000) + .sign (key1.prv, key1.pub) + .work (*system.work.generate (open1->hash ())) + .build (); + auto send3 = builder + .send () + .previous (send2->hash ()) + .destination (nano::dev::genesis->account ()) + .balance (900) + .sign (key1.prv, key1.pub) + .work (*system.work.generate (send2->hash ())) + .build (); + auto send4 = builder + .send () + .previous (send3->hash ()) + .destination (nano::dev::genesis->account ()) + .balance (500) + .sign (key1.prv, key1.pub) + .work (*system.work.generate (send3->hash ())) + .build (); + auto receive1 = builder + .receive () + .previous (send1->hash ()) + .source (send2->hash ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (send1->hash ())) + .build (); + auto receive2 = builder + .receive () + .previous (receive1->hash ()) + .source (send3->hash ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (receive1->hash ())) + .build (); + auto receive3 = builder + .receive () + .previous (receive2->hash ()) + .source (send4->hash ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (receive2->hash ())) + .build (); + auto send5 = builder + .send () + .previous (receive3->hash ()) + .destination (key1.pub) + .balance (node->online_reps.delta () + 1) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (receive3->hash ())) + .build (); + auto receive4 = builder + .receive () + .previous (send4->hash ()) + .source (send5->hash ()) + .sign (key1.prv, key1.pub) + .work (*system.work.generate (send4->hash ())) + .build_shared (); 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 ())); + auto send6 = builder + .send () + .previous (send5->hash ()) + .destination (key2.pub) + .balance (node->online_reps.delta () + 1) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (send5->hash ())) + .build (); + // Unpocketed send { auto transaction = node->store.tx_begin_write (); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send1).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, open1).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send1).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *open1).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send2).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, receive1).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send2).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *receive1).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send3).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send4).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send3).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send4).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, receive2).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, receive3).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *receive2).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *receive3).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send5).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send6).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send5).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send6).code); } add_callback_stats (*node); @@ -445,7 +702,7 @@ TEST (confirmation_height, send_receive_between_2_accounts) 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 (send5->hash (), confirmation_height_info.frontier); ASSERT_EQ (7, account_info.block_count); ASSERT_FALSE (node->store.account.get (transaction, key1.pub, account_info)); @@ -477,27 +734,73 @@ TEST (confirmation_height, send_receive_self) auto node = system.add_node (node_config, node_flags); nano::block_hash latest (node->latest (nano::dev::genesis_key.pub)); - 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::block_builder builder; + auto send1 = builder + .send () + .previous (latest) + .destination (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 (latest)) + .build (); + auto receive1 = builder + .receive () + .previous (send1->hash ()) + .source (send1->hash ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (send1->hash ())) + .build_shared (); + auto send2 = builder + .send () + .previous (receive1->hash ()) + .destination (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 (receive1->hash ())) + .build (); + auto send3 = builder + .send () + .previous (send2->hash ()) + .destination (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 receive2 = builder + .receive () + .previous (send3->hash ()) + .source (send2->hash ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (send3->hash ())) + .build (); + auto receive3 = builder + .receive () + .previous (receive2->hash ()) + .source (send3->hash ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (receive2->hash ())) + .build_shared (); // 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 ())); + auto send4 = builder + .send () + .previous (receive3->hash ()) + .destination (key1.pub) + .balance (node->online_reps.delta ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (receive3->hash ())) + .build (); { auto transaction = node->store.tx_begin_write (); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send1).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, receive1).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send2).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send3).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send1).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *receive1).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send2).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send3).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, receive2).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *receive2).code); ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *receive3).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send4).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send4).code); } add_callback_stats (*node); @@ -542,60 +845,209 @@ TEST (confirmation_height, all_block_types) nano::keypair key1; nano::keypair key2; auto & store = node->store; - nano::send_block send (latest, key1.pub, nano::dev::constants.genesis_amount - nano::Gxrb_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::Gxrb_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::state_block state_open (key2.pub, 0, 0, nano::Gxrb_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 ())); - nano::state_block state_receive (key2.pub, state_open.hash (), 0, nano::Gxrb_ratio * 2, send2.hash (), key2.prv, key2.pub, *system.work.generate (state_open.hash ())); - - nano::state_block state_send (key2.pub, state_receive.hash (), 0, nano::Gxrb_ratio, key1.pub, key2.prv, key2.pub, *system.work.generate (state_receive.hash ())); - nano::receive_block receive (send2.hash (), state_send.hash (), key1.prv, key1.pub, *system.work.generate (send2.hash ())); - - 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::Gxrb_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::Gxrb_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::Gxrb_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::Gxrb_ratio - 1, key2.pub, key1.prv, key1.pub, *system.work.generate (epoch1.hash ())); - nano::state_block state_receive2 (key2.pub, epoch.hash (), 0, nano::Gxrb_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::Gxrb_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::Gxrb_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::Gxrb_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::Gxrb_ratio * 2 + 1, state_send4.hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send1.hash ())); + nano::block_builder builder; + auto send = builder + .send () + .previous (latest) + .destination (key1.pub) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (latest)) + .build (); + auto send1 = builder + .send () + .previous (send->hash ()) + .destination (key2.pub) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 2) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (send->hash ())) + .build (); + + auto open = builder + .open () + .source (send->hash ()) + .representative (nano::dev::genesis_key.pub) + .account (key1.pub) + .sign (key1.prv, key1.pub) + .work (*system.work.generate (key1.pub)) + .build (); + auto state_open = builder + .state () + .account (key2.pub) + .previous (0) + .representative (0) + .balance (nano::Gxrb_ratio) + .link (send1->hash ()) + .sign (key2.prv, key2.pub) + .work (*system.work.generate (key2.pub)) + .build (); + + auto send2 = builder + .send () + .previous (open->hash ()) + .destination (key2.pub) + .balance (0) + .sign (key1.prv, key1.pub) + .work (*system.work.generate (open->hash ())) + .build (); + auto state_receive = builder + .state () + .account (key2.pub) + .previous (state_open->hash ()) + .representative (0) + .balance (nano::Gxrb_ratio * 2) + .link (send2->hash ()) + .sign (key2.prv, key2.pub) + .work (*system.work.generate (state_open->hash ())) + .build (); + + auto state_send = builder + .state () + .account (key2.pub) + .previous (state_receive->hash ()) + .representative (0) + .balance (nano::Gxrb_ratio) + .link (key1.pub) + .sign (key2.prv, key2.pub) + .work (*system.work.generate (state_receive->hash ())) + .build (); + auto receive = builder + .receive () + .previous (send2->hash ()) + .source (state_send->hash ()) + .sign (key1.prv, key1.pub) + .work (*system.work.generate (send2->hash ())) + .build (); + + auto change = builder + .change () + .previous (receive->hash ()) + .representative (key2.pub) + .sign (key1.prv, key1.pub) + .work (*system.work.generate (receive->hash ())) + .build (); + + auto state_change = builder + .state () + .account (key2.pub) + .previous (state_send->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::Gxrb_ratio) + .link (0) + .sign (key2.prv, key2.pub) + .work (*system.work.generate (state_send->hash ())) + .build (); + + auto epoch = builder + .state () + .account (key2.pub) + .previous (state_change->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::Gxrb_ratio) + .link (node->ledger.epoch_link (nano::epoch::epoch_1)) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (state_change->hash ())) + .build (); + + auto epoch1 = builder + .state () + .account (key1.pub) + .previous (change->hash ()) + .representative (key2.pub) + .balance (nano::Gxrb_ratio) + .link (node->ledger.epoch_link (nano::epoch::epoch_1)) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (change->hash ())) + .build (); + auto state_send1 = builder + .state () + .account (key1.pub) + .previous (epoch1->hash ()) + .representative (0) + .balance (nano::Gxrb_ratio - 1) + .link (key2.pub) + .sign (key1.prv, key1.pub) + .work (*system.work.generate (epoch1->hash ())) + .build (); + auto state_receive2 = builder + .state () + .account (key2.pub) + .previous (epoch->hash ()) + .representative (0) + .balance (nano::Gxrb_ratio + 1) + .link (state_send1->hash ()) + .sign (key2.prv, key2.pub) + .work (*system.work.generate (epoch->hash ())) + .build (); + + auto state_send2 = builder + .state () + .account (key2.pub) + .previous (state_receive2->hash ()) + .representative (0) + .balance (nano::Gxrb_ratio) + .link (key1.pub) + .sign (key2.prv, key2.pub) + .work (*system.work.generate (state_receive2->hash ())) + .build_shared (); + auto state_send3 = builder + .state () + .account (key2.pub) + .previous (state_send2->hash ()) + .representative (0) + .balance (nano::Gxrb_ratio - 1) + .link (key1.pub) + .sign (key2.prv, key2.pub) + .work (*system.work.generate (state_send2->hash ())) + .build (); + + auto state_send4 = builder + .state () + .account (key1.pub) + .previous (state_send1->hash ()) + .representative (0) + .balance (nano::Gxrb_ratio - 2) + .link (nano::dev::genesis_key.pub) + .sign (key1.prv, key1.pub) + .work (*system.work.generate (state_send1->hash ())) + .build (); + auto state_receive3 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (send1->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 2 + 1) + .link (state_send4->hash ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (send1->hash ())) + .build (); { auto transaction (store.tx_begin_write ()); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send1).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, open).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, state_open).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send1).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *open).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *state_open).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send2).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, state_receive).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send2).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *state_receive).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, state_send).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, receive).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, change).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, state_change).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *state_send).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *receive).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *change).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *state_change).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, epoch).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, epoch1).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *epoch).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *epoch1).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, state_send1).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, state_receive2).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *state_send1).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *state_receive2).code); ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *state_send2).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, state_send3).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *state_send3).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, state_send4).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, state_receive3).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *state_send4).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *state_receive3).code); } add_callback_stats (*node); @@ -613,12 +1065,12 @@ TEST (confirmation_height, all_block_types) 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_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_EQ (state_send1.hash (), confirmation_height_info.frontier); + ASSERT_EQ (state_send1->hash (), confirmation_height_info.frontier); ASSERT_EQ (6, confirmation_height_info.height); ASSERT_LE (7, account_info.block_count); @@ -761,7 +1213,15 @@ TEST (confirmation_heightDeathTest, rollback_added_block) nano::write_database_queue write_database_queue (false); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; - auto send = std::make_shared (nano::dev::genesis->hash (), key1.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); + nano::block_builder builder; + auto send = builder + .send () + .previous (nano::dev::genesis->hash ()) + .destination (key1.pub) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build_shared (); { auto transaction (store->tx_begin_write ()); store->initialize (transaction, ledger.cache, ledger.constants); @@ -793,7 +1253,15 @@ TEST (confirmation_height, observers) 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))); + nano::block_builder builder; + auto send1 = builder + .send () + .previous (latest1) + .destination (key1.pub) + .balance (amount - node1->config.receive_minimum.number ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (latest1)) + .build_shared (); add_callback_stats (*node1); @@ -837,7 +1305,15 @@ TEST (confirmation_heightDeathTest, modified_chain) nano::write_database_queue write_database_queue (false); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; - auto send = std::make_shared (nano::dev::genesis->hash (), key1.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); + nano::block_builder builder; + auto send = builder + .send () + .previous (nano::dev::genesis->hash ()) + .destination (key1.pub) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build_shared (); { auto transaction (store->tx_begin_write ()); store->initialize (transaction, ledger.cache, ledger.constants); @@ -907,8 +1383,25 @@ TEST (confirmation_heightDeathTest, modified_chain_account_removed) nano::write_database_queue write_database_queue (false); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; - auto send = std::make_shared (nano::dev::genesis->hash (), key1.pub, nano::dev::constants.genesis_amount - nano::Gxrb_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::Gxrb_ratio, send->hash (), key1.prv, key1.pub, *pool.generate (key1.pub)); + nano::block_builder builder; + auto send = builder + .send () + .previous (nano::dev::genesis->hash ()) + .destination (key1.pub) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build_shared (); + auto open = builder + .state () + .account (key1.pub) + .previous (0) + .representative (0) + .balance (nano::Gxrb_ratio) + .link (send->hash ()) + .sign (key1.prv, key1.pub) + .work (*pool.generate (key1.pub)) + .build_shared (); { auto transaction (store->tx_begin_write ()); store->initialize (transaction, ledger.cache, ledger.constants); @@ -970,12 +1463,27 @@ TEST (confirmation_height, pending_observer_callbacks) nano::block_hash latest (node->latest (nano::dev::genesis_key.pub)); nano::keypair key1; - nano::send_block send (latest, key1.pub, nano::dev::constants.genesis_amount - nano::Gxrb_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::Gxrb_ratio * 2, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send.hash ())); + nano::block_builder builder; + auto send = builder + .send () + .previous (latest) + .destination (key1.pub) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (latest)) + .build (); + auto send1 = builder + .send () + .previous (send->hash ()) + .destination (key1.pub) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 2) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (send->hash ())) + .build_shared (); { auto transaction = node->store.tx_begin_write (); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code); ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send1).code); } @@ -1012,13 +1520,28 @@ TEST (confirmation_height, callback_confirmed_history) nano::block_hash latest (node->latest (nano::dev::genesis_key.pub)); nano::keypair key1; - auto send = std::make_shared (latest, key1.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest)); + nano::block_builder builder; + auto send = builder + .send () + .previous (latest) + .destination (key1.pub) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (latest)) + .build_shared (); { 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::dev::constants.genesis_amount - nano::Gxrb_ratio * 2, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send->hash ())); + auto send1 = builder + .send () + .previous (send->hash ()) + .destination (key1.pub) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 2) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (send->hash ())) + .build_shared (); add_callback_stats (*node); @@ -1093,9 +1616,31 @@ TEST (confirmation_height, dependent_election) nano::block_hash latest (node->latest (nano::dev::genesis_key.pub)); nano::keypair key1; - auto send = std::make_shared (latest, key1.pub, nano::dev::constants.genesis_amount - nano::Gxrb_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::Gxrb_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::Gxrb_ratio * 3, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send1->hash ())); + nano::block_builder builder; + auto send = builder + .send () + .previous (latest) + .destination (key1.pub) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (latest)) + .build_shared (); + auto send1 = builder + .send () + .previous (send->hash ()) + .destination (key1.pub) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 2) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (send->hash ())) + .build_shared (); + auto send2 = builder + .send () + .previous (send1->hash ()) + .destination (key1.pub) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 3) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (send1->hash ())) + .build_shared (); { auto transaction = node->store.tx_begin_write (); ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code); @@ -1143,42 +1688,118 @@ TEST (confirmation_height, cemented_gap_below_receive) nano::block_hash latest (node->latest (nano::dev::genesis_key.pub)); nano::keypair key1; + nano::block_builder builder; system.wallet (0)->insert_adhoc (key1.prv); - nano::send_block send (latest, key1.pub, nano::dev::constants.genesis_amount - nano::Gxrb_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::Gxrb_ratio * 2, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send.hash ())); + auto send = builder + .send () + .previous (latest) + .destination (key1.pub) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (latest)) + .build (); + auto send1 = builder + .send () + .previous (send->hash ()) + .destination (key1.pub) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 2) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (send->hash ())) + .build (); nano::keypair dummy_key; - nano::send_block dummy_send (send1.hash (), dummy_key.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 3, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send1.hash ())); - - 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::Gxrb_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::dev::constants.genesis_amount - nano::Gxrb_ratio * 3, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (receive2.hash ())); + auto dummy_send = builder + .send () + .previous (send1->hash ()) + .destination (dummy_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 3) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (send1->hash ())) + .build (); + + auto open = builder + .open () + .source (send->hash ()) + .representative (nano::dev::genesis->account ()) + .account (key1.pub) + .sign (key1.prv, key1.pub) + .work (*system.work.generate (key1.pub)) + .build (); + auto receive1 = builder + .receive () + .previous (open->hash ()) + .source (send1->hash ()) + .sign (key1.prv, key1.pub) + .work (*system.work.generate (open->hash ())) + .build (); + auto send2 = builder + .send () + .previous (receive1->hash ()) + .destination (nano::dev::genesis_key.pub) + .balance (nano::Gxrb_ratio) + .sign (key1.prv, key1.pub) + .work (*system.work.generate (receive1->hash ())) + .build (); + + auto receive2 = builder + .receive () + .previous (dummy_send->hash ()) + .source (send2->hash ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (dummy_send->hash ())) + .build (); + auto dummy_send1 = builder + .send () + .previous (receive2->hash ()) + .destination (dummy_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 3) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (receive2->hash ())) + .build (); nano::keypair key2; system.wallet (0)->insert_adhoc (key2.prv); - nano::send_block send3 (dummy_send1.hash (), key2.pub, nano::dev::constants.genesis_amount - nano::Gxrb_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::Gxrb_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::dev::genesis->account (), key2.pub, key2.prv, key2.pub, *system.work.generate (key2.pub)); + auto send3 = builder + .send () + .previous (dummy_send1->hash ()) + .destination (key2.pub) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 4) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (dummy_send1->hash ())) + .build (); + auto dummy_send2 = builder + .send () + .previous (send3->hash ()) + .destination (dummy_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 5) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (send3->hash ())) + .build (); + + auto open1 = builder + .open () + .source (send3->hash ()) + .representative (nano::dev::genesis->account ()) + .account (key2.pub) + .sign (key2.prv, key2.pub) + .work (*system.work.generate (key2.pub)) + .build_shared (); { auto transaction = node->store.tx_begin_write (); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send1).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, dummy_send).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send1).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *dummy_send).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, open).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, receive1).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send2).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *open).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *receive1).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send2).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, receive2).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, dummy_send1).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *receive2).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *dummy_send1).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send3).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, dummy_send2).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send3).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *dummy_send2).code); ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *open1).code); } @@ -1204,7 +1825,7 @@ TEST (confirmation_height, cemented_gap_below_receive) ASSERT_EQ (0, node->active.election_winner_details_size ()); // Check that the order of callbacks is correct - std::vector expected_order = { send.hash (), open.hash (), send1.hash (), receive1.hash (), send2.hash (), dummy_send.hash (), receive2.hash (), dummy_send1.hash (), send3.hash (), open1->hash () }; + std::vector expected_order = { send->hash (), open->hash (), send1->hash (), receive1->hash (), send2->hash (), dummy_send->hash (), receive2->hash (), dummy_send1->hash (), send3->hash (), open1->hash () }; nano::lock_guard guard (mutex); ASSERT_EQ (observer_order, expected_order); }; @@ -1230,40 +1851,116 @@ TEST (confirmation_height, cemented_gap_below_no_cache) nano::keypair key1; system.wallet (0)->insert_adhoc (key1.prv); - nano::send_block send (latest, key1.pub, nano::dev::constants.genesis_amount - nano::Gxrb_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::Gxrb_ratio * 2, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send.hash ())); + nano::block_builder builder; + auto send = builder + .send () + .previous (latest) + .destination (key1.pub) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (latest)) + .build (); + auto send1 = builder + .send () + .previous (send->hash ()) + .destination (key1.pub) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 2) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (send->hash ())) + .build (); nano::keypair dummy_key; - nano::send_block dummy_send (send1.hash (), dummy_key.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 3, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send1.hash ())); - - 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::Gxrb_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::dev::constants.genesis_amount - nano::Gxrb_ratio * 3, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (receive2.hash ())); + auto dummy_send = builder + .send () + .previous (send1->hash ()) + .destination (dummy_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 3) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (send1->hash ())) + .build (); + + auto open = builder + .open () + .source (send->hash ()) + .representative (nano::dev::genesis->account ()) + .account (key1.pub) + .sign (key1.prv, key1.pub) + .work (*system.work.generate (key1.pub)) + .build (); + auto receive1 = builder + .receive () + .previous (open->hash ()) + .source (send1->hash ()) + .sign (key1.prv, key1.pub) + .work (*system.work.generate (open->hash ())) + .build (); + auto send2 = builder + .send () + .previous (receive1->hash ()) + .destination (nano::dev::genesis_key.pub) + .balance (nano::Gxrb_ratio) + .sign (key1.prv, key1.pub) + .work (*system.work.generate (receive1->hash ())) + .build (); + + auto receive2 = builder + .receive () + .previous (dummy_send->hash ()) + .source (send2->hash ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (dummy_send->hash ())) + .build (); + auto dummy_send1 = builder + .send () + .previous (receive2->hash ()) + .destination (dummy_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 3) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (receive2->hash ())) + .build (); nano::keypair key2; system.wallet (0)->insert_adhoc (key2.prv); - nano::send_block send3 (dummy_send1.hash (), key2.pub, nano::dev::constants.genesis_amount - nano::Gxrb_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::Gxrb_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::dev::genesis->account (), key2.pub, key2.prv, key2.pub, *system.work.generate (key2.pub)); + auto send3 = builder + .send () + .previous (dummy_send1->hash ()) + .destination (key2.pub) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 4) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (dummy_send1->hash ())) + .build (); + auto dummy_send2 = builder + .send () + .previous (send3->hash ()) + .destination (dummy_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 5) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (send3->hash ())) + .build (); + + auto open1 = builder + .open () + .source (send3->hash ()) + .representative (nano::dev::genesis->account ()) + .account (key2.pub) + .sign (key2.prv, key2.pub) + .work (*system.work.generate (key2.pub)) + .build_shared (); { auto transaction = node->store.tx_begin_write (); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send1).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, dummy_send).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send1).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *dummy_send).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, open).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, receive1).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send2).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *open).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *receive1).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send2).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, receive2).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, dummy_send1).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *receive2).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *dummy_send1).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send3).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, dummy_send2).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send3).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *dummy_send2).code); ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *open1).code); } @@ -1271,8 +1968,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::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 () }); + 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); @@ -1371,7 +2068,15 @@ 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::dev::genesis->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (nano::dev::genesis->hash ())); + nano::block_builder builder; + auto send = builder + .send () + .previous (nano::dev::genesis->hash ()) + .destination (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) + .build_shared (); // 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; @@ -1398,8 +2103,23 @@ TEST (confirmation_height, unbounded_block_cache_iteration) nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::logging logging; nano::keypair key1; - auto send = std::make_shared (nano::dev::genesis->hash (), key1.pub, nano::dev::constants.genesis_amount - nano::Gxrb_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::Gxrb_ratio * 2, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (send->hash ())); + nano::block_builder builder; + auto send = builder + .send () + .previous (nano::dev::genesis->hash ()) + .destination (key1.pub) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build_shared (); + auto send1 = builder + .send () + .previous (send->hash ()) + .destination (key1.pub) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 2) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (send->hash ())) + .build_shared (); { auto transaction (store->tx_begin_write ()); store->initialize (transaction, ledger.cache, nano::dev::constants); @@ -1447,11 +2167,57 @@ TEST (confirmation_height, pruned_source) nano::write_database_queue write_database_queue (false); 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, 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)); + nano::block_builder builder; + auto send1 = builder + .state () + .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 (key1.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build_shared (); + auto open1 = builder + .state () + .account (key1.pub) + .previous (0) + .representative (key1.pub) + .balance (100) + .link (send1->hash ()) + .sign (key1.prv, key1.pub) + .work (*pool.generate (key1.pub)) + .build_shared (); + auto send2 = builder + .state () + .account (key1.pub) + .previous (open1->hash ()) + .representative (key1.pub) + .balance (50) + .link (key2.pub) + .sign (key1.prv, key1.pub) + .work (*pool.generate (open1->hash ())) + .build_shared (); + auto send3 = builder + .state () + .account (key1.pub) + .previous (send2->hash ()) + .representative (key1.pub) + .balance (25) + .link (key2.pub) + .sign (key1.prv, key1.pub) + .work (*pool.generate (send2->hash ())) + .build_shared (); + auto open2 = builder + .state () + .account (key2.pub) + .previous (0) + .representative (key1.pub) + .balance (50) + .link (send2->hash ()) + .sign (key2.prv, key2.pub) + .work (*pool.generate (key2.pub)) + .build_shared (); { auto transaction (store->tx_begin_write ()); store->initialize (transaction, ledger.cache, nano::dev::constants); diff --git a/nano/core_test/confirmation_solicitor.cpp b/nano/core_test/confirmation_solicitor.cpp index d9fa2c2e8a..7b92d783ed 100644 --- a/nano/core_test/confirmation_solicitor.cpp +++ b/nano/core_test/confirmation_solicitor.cpp @@ -28,7 +28,15 @@ TEST (confirmation_solicitor, batches) ASSERT_EQ (channel1, representatives.front ().channel); ASSERT_EQ (nano::dev::genesis_key.pub, representatives.front ().account); ASSERT_TIMELY (3s, node2.network.size () == 1); - 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 ()))); + nano::block_builder builder; + auto send = builder + .send () + .previous (nano::dev::genesis->hash ()) + .destination (nano::keypair ().pub) + .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 (); send->sideband_set ({}); { nano::lock_guard guard (node2.active.mutex); @@ -71,7 +79,15 @@ TEST (confirmation_solicitor, different_hash) ASSERT_EQ (channel1, representatives.front ().channel); ASSERT_EQ (nano::dev::genesis_key.pub, representatives.front ().account); ASSERT_TIMELY (3s, node2.network.size () == 1); - 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 ()))); + nano::block_builder builder; + auto send = builder + .send () + .previous (nano::dev::genesis->hash ()) + .destination (nano::keypair ().pub) + .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 (); 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 @@ -107,7 +123,15 @@ 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::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 ()))); + nano::block_builder builder; + auto send = builder + .send () + .previous (nano::dev::genesis->hash ()) + .destination (nano::keypair ().pub) + .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 (); 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 453e85e0d2..d243f500a3 100644 --- a/nano/core_test/conflicts.cpp +++ b/nano/core_test/conflicts.cpp @@ -13,7 +13,15 @@ TEST (conflicts, start_stop) nano::system system (1); auto & node1 (*system.nodes[0]); nano::keypair key1; - auto send1 (std::make_shared (nano::dev::genesis->hash (), key1.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0)); + nano::block_builder builder; + auto send1 = builder + .send () + .previous (nano::dev::genesis->hash ()) + .destination (key1.pub) + .balance (0) + .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); ASSERT_EQ (0, node1.active.size ()); @@ -30,12 +38,27 @@ TEST (conflicts, add_existing) nano::system system{ 1 }; auto & node1 = *system.nodes[0]; nano::keypair key1; - auto send1 = std::make_shared (nano::dev::genesis->hash (), key1.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0); + nano::block_builder builder; + auto send1 = builder + .send () + .previous (nano::dev::genesis->hash ()) + .destination (key1.pub) + .balance (0) + .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); node1.scheduler.activate (nano::dev::genesis_key.pub, node1.store.tx_begin_read ()); nano::keypair key2; - auto send2 = std::make_shared (nano::dev::genesis->hash (), key2.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0); + auto send2 = builder + .send () + .previous (nano::dev::genesis->hash ()) + .destination (key2.pub) + .balance (0) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (0) + .build_shared (); node1.work_generate_blocking (*send2); send2->sideband_set ({}); node1.block_processor.add (send2); @@ -146,7 +169,17 @@ TEST (vote_uniquer, vbh_one) nano::block_uniquer block_uniquer; nano::vote_uniquer uniquer (block_uniquer); nano::keypair key; - auto block (std::make_shared (0, 0, 0, 0, 0, key.prv, key.pub, 0)); + nano::block_builder builder; + auto block = builder + .state () + .account (0) + .previous (0) + .representative (0) + .balance (0) + .link (0) + .sign (key.prv, key.pub) + .work (0) + .build_shared (); std::vector hashes; hashes.push_back (block->hash ()); auto vote1 (std::make_shared (key.pub, key.prv, 0, 0, hashes)); @@ -160,10 +193,29 @@ TEST (vote_uniquer, vbh_two) nano::block_uniquer block_uniquer; nano::vote_uniquer uniquer (block_uniquer); nano::keypair key; - auto block1 (std::make_shared (0, 0, 0, 0, 0, key.prv, key.pub, 0)); + nano::block_builder builder; + auto block1 = builder + .state () + .account (0) + .previous (0) + .representative (0) + .balance (0) + .link (0) + .sign (key.prv, key.pub) + .work (0) + .build_shared (); std::vector hashes1; hashes1.push_back (block1->hash ()); - auto block2 (std::make_shared (1, 0, 0, 0, 0, key.prv, key.pub, 0)); + auto block2 = builder + .state () + .account (1) + .previous (0) + .representative (0) + .balance (0) + .link (0) + .sign (key.prv, key.pub) + .work (0) + .build_shared (); std::vector hashes2; hashes2.push_back (block2->hash ()); auto vote1 (std::make_shared (key.pub, key.prv, 0, 0, hashes1)); diff --git a/nano/core_test/frontiers_confirmation.cpp b/nano/core_test/frontiers_confirmation.cpp index 1773b8a146..dd516e4851 100644 --- a/nano/core_test/frontiers_confirmation.cpp +++ b/nano/core_test/frontiers_confirmation.cpp @@ -20,51 +20,157 @@ TEST (frontiers_confirmation, prioritize_frontiers) nano::keypair key2; nano::keypair key3; nano::keypair key4; + nano::block_builder builder; 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 ())); + auto send1 = builder + .send () + .previous (latest1) + .destination (key1.pub) + .balance (node->config.online_weight_minimum.number () + 10000) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (latest1)) + .build (); + auto send2 = builder + .send () + .previous (send1->hash ()) + .destination (key1.pub) + .balance (node->config.online_weight_minimum.number () + 8500) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (send1->hash ())) + .build (); + auto send3 = builder + .send () + .previous (send2->hash ()) + .destination (key1.pub) + .balance (node->config.online_weight_minimum.number () + 8000) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (send2->hash ())) + .build (); + auto send4 = builder + .send () + .previous (send3->hash ()) + .destination (key2.pub) + .balance (node->config.online_weight_minimum.number () + 7500) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (send3->hash ())) + .build (); + auto send5 = builder + .send () + .previous (send4->hash ()) + .destination (key3.pub) + .balance (node->config.online_weight_minimum.number () + 6500) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (send4->hash ())) + .build (); + auto send6 = builder + .send () + .previous (send5->hash ()) + .destination (key4.pub) + .balance (node->config.online_weight_minimum.number () + 6000) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (send5->hash ())) + .build (); // 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::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::dev::genesis->account (), key2.pub, key2.prv, key2.pub, *system.work.generate (key2.pub)); - - 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::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 open1 = builder + .open () + .source (send1->hash ()) + .representative (nano::dev::genesis->account ()) + .account (key1.pub) + .sign (key1.prv, key1.pub) + .work (*system.work.generate (key1.pub)) + .build (); + auto send7 = builder + .send () + .previous (open1->hash ()) + .destination (nano::dev::genesis_key.pub) + .balance (500) + .sign (key1.prv, key1.pub) + .work (*system.work.generate (open1->hash ())) + .build (); + + auto open2 = builder + .open () + .source (send4->hash ()) + .representative (nano::dev::genesis->account ()) + .account (key2.pub) + .sign (key2.prv, key2.pub) + .work (*system.work.generate (key2.pub)) + .build (); + + auto open3 = builder + .open () + .source (send5->hash ()) + .representative (nano::dev::genesis->account ()) + .account (key3.pub) + .sign (key3.prv, key3.pub) + .work (*system.work.generate (key3.pub)) + .build (); + auto send8 = builder + .send () + .previous (open3->hash ()) + .destination (nano::dev::genesis_key.pub) + .balance (500) + .sign (key3.prv, key3.pub) + .work (*system.work.generate (open3->hash ())) + .build (); + auto send9 = builder + .send () + .previous (send8->hash ()) + .destination (nano::dev::genesis_key.pub) + .balance (200) + .sign (key3.prv, key3.pub) + .work (*system.work.generate (send8->hash ())) + .build (); + + auto open4 = builder + .open () + .source (send6->hash ()) + .representative (nano::dev::genesis->account ()) + .account (key4.pub) + .sign (key4.prv, key4.pub) + .work (*system.work.generate (key4.pub)) + .build (); + auto send10 = builder + .send () + .previous (open4->hash ()) + .destination (nano::dev::genesis_key.pub) + .balance (500) + .sign (key4.prv, key4.pub) + .work (*system.work.generate (open4->hash ())) + .build (); + auto send11 = builder + .send () + .previous (send10->hash ()) + .destination (nano::dev::genesis_key.pub) + .balance (200) + .sign (key4.prv, key4.pub) + .work (*system.work.generate (send10->hash ())) + .build (); { auto transaction = node->store.tx_begin_write (); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send1).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send2).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send3).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send4).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send5).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send6).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send1).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send2).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send3).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send4).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send5).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send6).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, open1).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send7).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *open1).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send7).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, open2).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *open2).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, open3).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send8).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send9).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *open3).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send8).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send9).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, open4).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send10).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send11).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *open4).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send10).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send11).code); } auto transaction = node->store.tx_begin_read (); @@ -111,20 +217,62 @@ TEST (frontiers_confirmation, prioritize_frontiers) } // 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 ())); + auto send12 = builder + .send () + .previous (send9->hash ()) + .destination (nano::dev::genesis_key.pub) + .balance (100) + .sign (key3.prv, key3.pub) + .work (*system.work.generate (send9->hash ())) + .build (); + auto send13 = builder + .send () + .previous (send12->hash ()) + .destination (nano::dev::genesis_key.pub) + .balance (90) + .sign (key3.prv, key3.pub) + .work (*system.work.generate (send12->hash ())) + .build (); + auto send14 = builder + .send () + .previous (send13->hash ()) + .destination (nano::dev::genesis_key.pub) + .balance (80) + .sign (key3.prv, key3.pub) + .work (*system.work.generate (send13->hash ())) + .build (); + auto send15 = builder + .send () + .previous (send14->hash ()) + .destination (nano::dev::genesis_key.pub) + .balance (70) + .sign (key3.prv, key3.pub) + .work (*system.work.generate (send14->hash ())) + .build (); + auto send16 = builder + .send () + .previous (send15->hash ()) + .destination (nano::dev::genesis_key.pub) + .balance (60) + .sign (key3.prv, key3.pub) + .work (*system.work.generate (send15->hash ())) + .build (); + auto send17 = builder + .send () + .previous (send16->hash ()) + .destination (nano::dev::genesis_key.pub) + .balance (50) + .sign (key3.prv, key3.pub) + .work (*system.work.generate (send16->hash ())) + .build (); { auto transaction = node->store.tx_begin_write (); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send12).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send13).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send14).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send15).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send16).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send17).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send12).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send13).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send14).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send15).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send16).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send17).code); } transaction.refresh (); node->active.prioritize_frontiers_for_confirmation (transaction, std::chrono::seconds (1), std::chrono::seconds (1)); @@ -135,7 +283,7 @@ TEST (frontiers_confirmation, prioritize_frontiers) // Check that the active transactions roots contains the frontiers ASSERT_TIMELY (10s, node->active.size () == num_accounts); - std::array frontiers{ send17.qualified_root (), send6.qualified_root (), send7.qualified_root (), open2.qualified_root (), send11.qualified_root () }; + std::array frontiers{ send17->qualified_root (), send6->qualified_root (), send7->qualified_root (), open2->qualified_root (), send11->qualified_root () }; for (auto & frontier : frontiers) { ASSERT_TRUE (node->active.active (frontier)); @@ -161,10 +309,25 @@ TEST (frontiers_confirmation, prioritize_frontiers_max_optimistic_elections) auto transaction = node->store.tx_begin_write (); 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)); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send).code); - 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); + nano::block_builder builder; + auto send = builder + .send () + .previous (latest) + .destination (key.pub) + .balance (node->config.online_weight_minimum.number () + 10000) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (latest)) + .build (); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code); + auto open = builder + .open () + .source (send->hash ()) + .representative (nano::dev::genesis->account ()) + .account (key.pub) + .sign (key.prv, key.pub) + .work (*system.work.generate (key.pub)) + .build (); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *open).code); } { @@ -211,6 +374,7 @@ TEST (frontiers_confirmation, expired_optimistic_elections_removal) TEST (frontiers_confirmation, mode) { nano::keypair key; + nano::block_builder builder; nano::node_flags node_flags; // Always mode { @@ -218,10 +382,19 @@ 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, nano::dev::genesis->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node->work_generate_blocking (nano::dev::genesis->hash ())); + auto send = builder + .state () + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .link (key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node->work_generate_blocking (nano::dev::genesis->hash ())) + .build (); { auto transaction = node->store.tx_begin_write (); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code); } ASSERT_TIMELY (5s, node->active.size () == 1); } @@ -231,10 +404,19 @@ 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, nano::dev::genesis->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node->work_generate_blocking (nano::dev::genesis->hash ())); + auto send = builder + .state () + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .link (key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node->work_generate_blocking (nano::dev::genesis->hash ())) + .build (); { auto transaction = node->store.tx_begin_write (); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code); } ASSERT_TIMELY (5s, node->active.size () == 1); } @@ -244,10 +426,19 @@ 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, nano::dev::genesis->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node->work_generate_blocking (nano::dev::genesis->hash ())); + auto send = builder + .state () + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .link (key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node->work_generate_blocking (nano::dev::genesis->hash ())) + .build (); { auto transaction = node->store.tx_begin_write (); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code); } system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); std::this_thread::sleep_for (std::chrono::seconds (1)); diff --git a/nano/core_test/gap_cache.cpp b/nano/core_test/gap_cache.cpp index 8c1d7a6b30..d468177445 100644 --- a/nano/core_test/gap_cache.cpp +++ b/nano/core_test/gap_cache.cpp @@ -9,7 +9,15 @@ TEST (gap_cache, add_new) { nano::system system (1); nano::gap_cache cache (*system.nodes[0]); - auto block1 (std::make_shared (0, 1, 2, nano::keypair ().prv, 4, 5)); + nano::block_builder builder; + auto block1 = builder + .send () + .previous (0) + .destination (1) + .balance (2) + .sign (nano::keypair ().prv, 4) + .work (5) + .build_shared (); cache.add (block1->hash ()); } @@ -17,7 +25,15 @@ TEST (gap_cache, add_existing) { nano::system system (1); nano::gap_cache cache (*system.nodes[0]); - auto block1 (std::make_shared (0, 1, 2, nano::keypair ().prv, 4, 5)); + nano::block_builder builder; + auto block1 = builder + .send () + .previous (0) + .destination (1) + .balance (2) + .sign (nano::keypair ().prv, 4) + .work (5) + .build_shared (); cache.add (block1->hash ()); nano::unique_lock lock (cache.mutex); auto existing1 (cache.blocks.get<1> ().find (block1->hash ())); @@ -37,7 +53,15 @@ TEST (gap_cache, comparison) { nano::system system (1); nano::gap_cache cache (*system.nodes[0]); - auto block1 (std::make_shared (1, 0, 2, nano::keypair ().prv, 4, 5)); + nano::block_builder builder; + auto block1 = builder + .send () + .previous (1) + .destination (0) + .balance (2) + .sign (nano::keypair ().prv, 4) + .work (5) + .build_shared (); cache.add (block1->hash ()); nano::unique_lock lock (cache.mutex); auto existing1 (cache.blocks.get<1> ().find (block1->hash ())); @@ -45,7 +69,14 @@ TEST (gap_cache, comparison) auto arrival (existing1->arrival); lock.unlock (); ASSERT_TIMELY (20s, std::chrono::steady_clock::now () != arrival); - auto block3 (std::make_shared (0, 42, 1, nano::keypair ().prv, 3, 4)); + auto block3 = builder + .send () + .previous (0) + .destination (42) + .balance (1) + .sign (nano::keypair ().prv, 3) + .work (4) + .build_shared (); cache.add (block3->hash ()); ASSERT_EQ (2, cache.size ()); lock.lock (); @@ -67,7 +98,15 @@ TEST (gap_cache, gap_bootstrap) auto & node2 (*system.nodes[1]); nano::block_hash latest (node1.latest (nano::dev::genesis_key.pub)); nano::keypair key; - 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))); + nano::block_builder builder; + auto send = builder + .send () + .previous (latest) + .destination (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 (); 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 ())); @@ -91,9 +130,31 @@ TEST (gap_cache, two_dependencies) nano::system system (1); auto & node1 (*system.nodes[0]); nano::keypair key; - 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))); + nano::block_builder builder; + auto send1 = builder + .send () + .previous (nano::dev::genesis->hash ()) + .destination (key.pub) + .balance (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 + .send () + .previous (send1->hash ()) + .destination (key.pub) + .balance (0) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (send1->hash ())) + .build_shared (); + auto open = builder + .open () + .source (send1->hash ()) + .representative (key.pub) + .account (key.pub) + .sign (key.prv, key.pub) + .work (*system.work.generate (key.pub)) + .build_shared (); ASSERT_EQ (0, node1.gap_cache.size ()); node1.block_processor.add (send2); node1.block_processor.flush (); diff --git a/nano/core_test/ledger.cpp b/nano/core_test/ledger.cpp index 0fcab39e4c..c6fd32dfc5 100644 --- a/nano/core_test/ledger.cpp +++ b/nano/core_test/ledger.cpp @@ -75,9 +75,19 @@ TEST (ledger, process_modifies_sideband) nano::ledger ledger (*store, stats, nano::dev::constants); store->initialize (store->tx_begin_write (), ledger.cache, ledger.constants); 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::Gxrb_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); + nano::block_builder builder; + auto send1 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .link (nano::dev::genesis->account ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); + 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); } // Create a send block and publish it. @@ -94,19 +104,27 @@ TEST (ledger, process_send) nano::account_info 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::block_hash hash1 (send.hash ()); + nano::block_builder builder; + auto send = builder + .send () + .previous (info1.head) + .destination (key2.pub) + .balance (50) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (info1.head)) + .build (); + nano::block_hash hash1 (send->hash ()); 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 (2, send.sideband ().height); + auto return1 (ledger.process (transaction, *send)); + ASSERT_EQ (nano::dev::genesis_key.pub, send->sideband ().account); + ASSERT_EQ (2, send->sideband ().height); 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 (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_receivable (transaction, key2.pub)); nano::account_info info2; @@ -116,19 +134,26 @@ TEST (ledger, process_send) ASSERT_NE (nullptr, latest6); auto latest7 (dynamic_cast (latest6.get ())); ASSERT_NE (nullptr, latest7); - ASSERT_EQ (send, *latest7); + ASSERT_EQ (*send, *latest7); // Create an open block opening an account accepting the send we just created - nano::open_block open (hash1, key2.pub, key2.pub, key2.prv, key2.pub, *pool.generate (key2.pub)); - nano::block_hash hash2 (open.hash ()); + auto open = builder + .open () + .source (hash1) + .representative (key2.pub) + .account (key2.pub) + .sign (key2.prv, key2.pub) + .work (*pool.generate (key2.pub)) + .build (); + nano::block_hash hash2 (open->hash ()); // This was a valid block, it should progress. - auto return2 (ledger.process (transaction, open)); + auto return2 (ledger.process (transaction, *open)); ASSERT_EQ (nano::process_result::progress, return2.code); - ASSERT_EQ (key2.pub, open.sideband ().account); - ASSERT_EQ (nano::dev::constants.genesis_amount - 50, open.sideband ().balance.number ()); - ASSERT_EQ (1, open.sideband ().height); + ASSERT_EQ (key2.pub, open->sideband ().account); + ASSERT_EQ (nano::dev::constants.genesis_amount - 50, open->sideband ().balance.number ()); + ASSERT_EQ (1, open->sideband ().height); 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 (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)); @@ -141,14 +166,14 @@ TEST (ledger, process_send) ASSERT_NE (nullptr, latest2); auto latest3 (dynamic_cast (latest2.get ())); ASSERT_NE (nullptr, latest3); - ASSERT_EQ (send, *latest3); + ASSERT_EQ (*send, *latest3); nano::account_info info4; ASSERT_FALSE (store->account.get (transaction, key2.pub, info4)); auto latest4 (store->block.get (transaction, info4.head)); ASSERT_NE (nullptr, latest4); auto latest5 (dynamic_cast (latest4.get ())); ASSERT_NE (nullptr, latest5); - ASSERT_EQ (open, *latest5); + ASSERT_EQ (*open, *latest5); ASSERT_FALSE (ledger.rollback (transaction, hash2)); ASSERT_TRUE (store->frontier.get (transaction, hash2).is_zero ()); nano::account_info info5; @@ -193,35 +218,63 @@ TEST (ledger, process_receive) nano::account_info 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::block_hash hash1 (send.hash ()); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send).code); + nano::block_builder builder; + auto send = builder + .send () + .previous (info1.head) + .destination (key2.pub) + .balance (50) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (info1.head)) + .build (); + nano::block_hash hash1 (send->hash ()); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send).code); nano::keypair key3; - nano::open_block open (hash1, key3.pub, key2.pub, key2.prv, key2.pub, *pool.generate (key2.pub)); - nano::block_hash hash2 (open.hash ()); - auto return1 (ledger.process (transaction, open)); + auto open = builder + .open () + .source (hash1) + .representative (key3.pub) + .account (key2.pub) + .sign (key2.prv, key2.pub) + .work (*pool.generate (key2.pub)) + .build (); + 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, open.sideband ().account); - ASSERT_EQ (nano::dev::constants.genesis_amount - 50, open.sideband ().balance.number ()); - ASSERT_EQ (1, open.sideband ().height); + ASSERT_EQ (key2.pub, store->block.account_calculated (*open)); + ASSERT_EQ (key2.pub, open->sideband ().account); + ASSERT_EQ (nano::dev::constants.genesis_amount - 50, open->sideband ().balance.number ()); + ASSERT_EQ (1, open->sideband ().height); 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 ()); + auto send2 = builder + .send () + .previous (hash1) + .destination (key2.pub) + .balance (25) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (hash1)) + .build (); + nano::block_hash hash3 (send2->hash ()); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send2).code); + auto receive = builder + .receive () + .previous (hash2) + .source (hash3) + .sign (key2.prv, key2.pub) + .work (*pool.generate (hash2)) + .build (); + auto hash4 (receive->hash ()); 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::dev::constants.genesis_amount - 25, receive.sideband ().balance.number ()); - ASSERT_EQ (2, receive.sideband ().height); + auto return2 (ledger.process (transaction, *receive)); + ASSERT_EQ (key2.pub, receive->sideband ().account); + 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_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 (0, ledger.account_receivable (transaction, key2.pub)); @@ -256,13 +309,28 @@ TEST (ledger, rollback_receiver) nano::account_info 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::block_hash hash1 (send.hash ()); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send).code); + nano::block_builder builder; + auto send = builder + .send () + .previous (info1.head) + .destination (key2.pub) + .balance (50) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (info1.head)) + .build (); + nano::block_hash hash1 (send->hash ()); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send).code); nano::keypair key3; - nano::open_block open (hash1, key3.pub, key2.pub, key2.prv, key2.pub, *pool.generate (key2.pub)); - nano::block_hash hash2 (open.hash ()); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, open).code); + auto open = builder + .open () + .source (hash1) + .representative (key3.pub) + .account (key2.pub) + .sign (key2.prv, key2.pub) + .work (*pool.generate (key2.pub)) + .build (); + 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::dev::constants.genesis_amount - 50, ledger.account_balance (transaction, key2.pub)); @@ -293,41 +361,81 @@ TEST (ledger, rollback_representation) store->initialize (transaction, ledger.cache, ledger.constants); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key5; - 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::block_builder builder; + auto change1 = builder + .change () + .previous (nano::dev::genesis->hash ()) + .representative (key5.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); + 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 ())); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, change2).code); + auto change2 = builder + .change () + .previous (change1->hash ()) + .representative (key3.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (change1->hash ())) + .build (); + 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 ())); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); + auto send1 = builder + .send () + .previous (change2->hash ()) + .destination (key2.pub) + .balance (50) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (change2->hash ())) + .build (); + 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 ())); - 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); + auto open = builder + .open () + .source (send1->hash ()) + .representative (key4.pub) + .account (key2.pub) + .sign (key2.prv, key2.pub) + .work (*pool.generate (key2.pub)) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *open).code); + auto send2 = builder + .send () + .previous (send1->hash ()) + .destination (key2.pub) + .balance (1) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (send1->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send2).code); + auto receive1 = builder + .receive () + .previous (open->hash ()) + .source (send2->hash ()) + .sign (key2.prv, key2.pub) + .work (*pool.generate (open->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *receive1).code); ASSERT_EQ (1, ledger.weight (key3.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_EQ (key4.pub, info1.representative); - ASSERT_FALSE (ledger.rollback (transaction, receive1.hash ())); + ASSERT_FALSE (ledger.rollback (transaction, receive1->hash ())); nano::account_info 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::dev::constants.genesis_amount - 50, ledger.weight (key4.pub)); - ASSERT_FALSE (ledger.rollback (transaction, open.hash ())); + 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 ()); + ledger.rollback (transaction, send1->hash ()); 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_EQ (key3.pub, info3.representative); - ASSERT_FALSE (ledger.rollback (transaction, change2.hash ())); + ASSERT_FALSE (ledger.rollback (transaction, change2->hash ())); nano::account_info info4; ASSERT_FALSE (store->account.get (transaction, nano::dev::genesis_key.pub, info4)); ASSERT_EQ (key5.pub, info4.representative); @@ -345,11 +453,25 @@ TEST (ledger, receive_rollback) auto transaction (store->tx_begin_write ()); store->initialize (transaction, ledger.cache, ledger.constants); 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::Gxrb_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 ())); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, receive).code); - ASSERT_FALSE (ledger.rollback (transaction, receive.hash ())); + nano::block_builder builder; + auto send = builder + .send () + .previous (nano::dev::genesis->hash ()) + .destination (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send).code); + auto receive = builder + .receive () + .previous (send->hash ()) + .source (send->hash ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (send->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *receive).code); + ASSERT_FALSE (ledger.rollback (transaction, receive->hash ())); } TEST (ledger, process_duplicate) @@ -365,13 +487,28 @@ TEST (ledger, process_duplicate) nano::account_info 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::block_hash hash1 (send.hash ()); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send).code); - ASSERT_EQ (nano::process_result::old, ledger.process (transaction, send).code); - nano::open_block open (hash1, 1, key2.pub, key2.prv, key2.pub, *pool.generate (key2.pub)); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, open).code); - ASSERT_EQ (nano::process_result::old, ledger.process (transaction, open).code); + nano::block_builder builder; + auto send = builder + .send () + .previous (info1.head) + .destination (key2.pub) + .balance (50) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (info1.head)) + .build (); + 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); + auto open = builder + .open () + .source (hash1) + .representative (1) + .account (key2.pub) + .sign (key2.prv, key2.pub) + .work (*pool.generate (key2.pub)) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *open).code); + ASSERT_EQ (nano::process_result::old, ledger.process (transaction, *open).code); } TEST (ledger, representative_genesis) @@ -415,22 +552,29 @@ TEST (ledger, representative_change) 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)); + nano::block_builder builder; + auto block = builder + .change () + .previous (info1.head) + .representative (key2.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (info1.head)) + .build (); 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 ())); + 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_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 (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_EQ (block.hash (), info2.head); + 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_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_EQ (info1.head, info3.head); @@ -452,10 +596,25 @@ TEST (ledger, send_fork) 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_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)); - ASSERT_EQ (nano::process_result::fork, ledger.process (transaction, block2).code); + nano::block_builder builder; + auto block = builder + .send () + .previous (info1.head) + .destination (key2.pub) + .balance (100) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (info1.head)) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *block).code); + auto block2 = builder + .send () + .previous (info1.head) + .destination (key3.pub) + .balance (0) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (info1.head)) + .build (); + ASSERT_EQ (nano::process_result::fork, ledger.process (transaction, *block2).code); } TEST (ledger, receive_fork) @@ -472,16 +631,50 @@ TEST (ledger, receive_fork) 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_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 ())); - 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); + nano::block_builder builder; + auto block = builder + .send () + .previous (info1.head) + .destination (key2.pub) + .balance (100) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (info1.head)) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *block).code); + auto block2 = builder + .open () + .source (block->hash ()) + .representative (key2.pub) + .account (key2.pub) + .sign (key2.prv, key2.pub) + .work (*pool.generate (key2.pub)) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *block2).code); + auto block3 = builder + .change () + .previous (block2->hash ()) + .representative (key3.pub) + .sign (key2.prv, key2.pub) + .work (*pool.generate (block2->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *block3).code); + auto block4 = builder + .send () + .previous (block->hash ()) + .destination (key2.pub) + .balance (0) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (block->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *block4).code); + auto block5 = builder + .receive () + .previous (block2->hash ()) + .source (block4->hash ()) + .sign (key2.prv, key2.pub) + .work (*pool.generate (block2->hash ())) + .build (); + ASSERT_EQ (nano::process_result::fork, ledger.process (transaction, *block5).code); } TEST (ledger, open_fork) @@ -498,12 +691,34 @@ TEST (ledger, open_fork) 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_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::open_block block3 (block.hash (), key3.pub, key2.pub, key2.prv, key2.pub, *pool.generate (key2.pub)); - ASSERT_EQ (nano::process_result::fork, ledger.process (transaction, block3).code); + nano::block_builder builder; + auto block = builder + .send () + .previous (info1.head) + .destination (key2.pub) + .balance (100) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (info1.head)) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *block).code); + auto block2 = builder + .open () + .source (block->hash ()) + .representative (key2.pub) + .account (key2.pub) + .sign (key2.prv, key2.pub) + .work (*pool.generate (key2.pub)) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *block2).code); + auto block3 = builder + .open () + .source (block->hash ()) + .representative (key3.pub) + .account (key2.pub) + .sign (key2.prv, key2.pub) + .work (*pool.generate (key2.pub)) + .build (); + ASSERT_EQ (nano::process_result::fork, ledger.process (transaction, *block3).code); } TEST (ledger, representation_changes) @@ -530,59 +745,120 @@ TEST (ledger, representation) 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 (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); + nano::block_builder builder; + auto block1 = builder + .send () + .previous (nano::dev::genesis->hash ()) + .destination (key2.pub) + .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 (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *block1).code); 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); + auto block2 = builder + .open () + .source (block1->hash ()) + .representative (key3.pub) + .account (key2.pub) + .sign (key2.prv, key2.pub) + .work (*pool.generate (key2.pub)) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *block2).code); 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::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); + auto block3 = builder + .send () + .previous (block1->hash ()) + .destination (key2.pub) + .balance (nano::dev::constants.genesis_amount - 200) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (block1->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *block3).code); 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); + auto block4 = builder + .receive () + .previous (block2->hash ()) + .source (block3->hash ()) + .sign (key2.prv, key2.pub) + .work (*pool.generate (block2->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *block4).code); 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); + auto block5 = builder + .change () + .previous (block4->hash ()) + .representative (key4.pub) + .sign (key2.prv, key2.pub) + .work (*pool.generate (block4->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *block5).code); 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); + auto block6 = builder + .send () + .previous (block5->hash ()) + .destination (key5.pub) + .balance (100) + .sign (key2.prv, key2.pub) + .work (*pool.generate (block5->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *block6).code); 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)); ASSERT_EQ (0, rep_weights.representation_get (key5.pub)); 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); + auto block7 = builder + .open () + .source (block6->hash ()) + .representative (key6.pub) + .account (key5.pub) + .sign (key5.prv, key5.pub) + .work (*pool.generate (key5.pub)) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *block7).code); 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)); ASSERT_EQ (0, rep_weights.representation_get (key5.pub)); 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); + auto block8 = builder + .send () + .previous (block6->hash ()) + .destination (key5.pub) + .balance (0) + .sign (key2.prv, key2.pub) + .work (*pool.generate (block6->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *block8).code); 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)); ASSERT_EQ (0, rep_weights.representation_get (key5.pub)); 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); + auto block9 = builder + .receive () + .previous (block7->hash ()) + .source (block8->hash ()) + .sign (key5.prv, key5.pub) + .work (*pool.generate (block7->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *block9).code); 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)); @@ -602,12 +878,34 @@ TEST (ledger, double_open) store->initialize (transaction, ledger.cache, ledger.constants); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key2; - 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)); - ASSERT_EQ (nano::process_result::fork, ledger.process (transaction, open2).code); + nano::block_builder builder; + auto send1 = builder + .send () + .previous (nano::dev::genesis->hash ()) + .destination (key2.pub) + .balance (1) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); + auto open1 = builder + .open () + .source (send1->hash ()) + .representative (key2.pub) + .account (key2.pub) + .sign (key2.prv, key2.pub) + .work (*pool.generate (key2.pub)) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *open1).code); + auto open2 = builder + .open () + .source (send1->hash ()) + .representative (nano::dev::genesis_key.pub) + .account (key2.pub) + .sign (key2.prv, key2.pub) + .work (*pool.generate (key2.pub)) + .build (); + ASSERT_EQ (nano::process_result::fork, ledger.process (transaction, *open2).code); } TEST (ledger, double_receive) @@ -621,12 +919,33 @@ TEST (ledger, double_receive) store->initialize (transaction, ledger.cache, ledger.constants); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key2; - 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::receive_block receive1 (open1.hash (), send1.hash (), key2.prv, key2.pub, *pool.generate (open1.hash ())); - ASSERT_EQ (nano::process_result::unreceivable, ledger.process (transaction, receive1).code); + nano::block_builder builder; + auto send1 = builder + .send () + .previous (nano::dev::genesis->hash ()) + .destination (key2.pub) + .balance (1) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); + auto open1 = builder + .open () + .source (send1->hash ()) + .representative (key2.pub) + .account (key2.pub) + .sign (key2.prv, key2.pub) + .work (*pool.generate (key2.pub)) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *open1).code); + auto receive1 = builder + .receive () + .previous (open1->hash ()) + .source (send1->hash ()) + .sign (key2.prv, key2.pub) + .work (*pool.generate (open1->hash ())) + .build (); + ASSERT_EQ (nano::process_result::unreceivable, ledger.process (transaction, *receive1).code); } TEST (votes, check_signature) @@ -636,7 +955,15 @@ TEST (votes, check_signature) node_config.online_weight_minimum = std::numeric_limits::max (); auto & node1 = *system.add_node (node_config); nano::keypair key1; - 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)); + nano::block_builder builder; + auto send1 = builder + .send () + .previous (nano::dev::genesis->hash ()) + .destination (key1.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); { auto transaction (node1.store.tx_begin_write ()); @@ -659,7 +986,15 @@ TEST (votes, add_one) nano::system system (1); auto & node1 (*system.nodes[0]); nano::keypair key1; - 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)); + nano::block_builder builder; + auto send1 = builder + .send () + .previous (nano::dev::genesis->hash ()) + .destination (key1.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); auto transaction (node1.store.tx_begin_write ()); ASSERT_EQ (nano::process_result::progress, node1.ledger.process (transaction, *send1).code); @@ -752,7 +1087,15 @@ TEST (votes, add_old) nano::system system (1); auto & node1 (*system.nodes[0]); nano::keypair key1; - auto send1 (std::make_shared (nano::dev::genesis->hash (), key1.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0)); + nano::block_builder builder; + auto send1 = builder + .send () + .previous (nano::dev::genesis->hash ()) + .destination (key1.pub) + .balance (0) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (0) + .build_shared (); node1.work_generate_blocking (*send1); auto transaction (node1.store.tx_begin_write ()); ASSERT_EQ (nano::process_result::progress, node1.ledger.process (transaction, *send1).code); @@ -763,9 +1106,16 @@ TEST (votes, add_old) auto channel (std::make_shared (node1, node1)); node1.vote_processor.vote_blocking (vote1, channel); nano::keypair key2; - auto send2 (std::make_shared (nano::dev::genesis->hash (), key2.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0)); + auto send2 = builder + .send () + .previous (nano::dev::genesis->hash ()) + .destination (key2.pub) + .balance (0) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (0) + .build_shared (); node1.work_generate_blocking (*send2); - auto vote2 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_min * 1, 0, std::vector{ send2->hash () })); + auto vote2 = std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_min * 1, 0, std::vector{ send2->hash () }); { nano::lock_guard lock (election1->mutex); election1->last_votes[nano::dev::genesis_key.pub].time = std::chrono::steady_clock::now () - std::chrono::seconds (20); @@ -788,9 +1138,24 @@ TEST (votes, DISABLED_add_old_different_account) nano::system system (1); auto & node1 (*system.nodes[0]); nano::keypair key1; - auto send1 (std::make_shared (nano::dev::genesis->hash (), key1.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0)); + nano::block_builder builder; + auto send1 = builder + .send () + .previous (nano::dev::genesis->hash ()) + .destination (key1.pub) + .balance (0) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (0) + .build_shared (); 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 = builder + .send () + .previous (send1->hash ()) + .destination (key1.pub) + .balance (0) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (0) + .build_shared (); 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); @@ -828,7 +1193,15 @@ TEST (votes, add_cooldown) nano::system system (1); auto & node1 (*system.nodes[0]); nano::keypair key1; - auto send1 (std::make_shared (nano::dev::genesis->hash (), key1.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0)); + nano::block_builder builder; + auto send1 = builder + .send () + .previous (nano::dev::genesis->hash ()) + .destination (key1.pub) + .balance (0) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (0) + .build_shared (); node1.work_generate_blocking (*send1); auto transaction (node1.store.tx_begin_write ()); ASSERT_EQ (nano::process_result::progress, node1.ledger.process (transaction, *send1).code); @@ -839,7 +1212,14 @@ TEST (votes, add_cooldown) auto channel (std::make_shared (node1, node1)); node1.vote_processor.vote_blocking (vote1, channel); nano::keypair key2; - auto send2 (std::make_shared (nano::dev::genesis->hash (), key2.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0)); + auto send2 = builder + .send () + .previous (nano::dev::genesis->hash ()) + .destination (key2.pub) + .balance (0) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (0) + .build_shared (); node1.work_generate_blocking (*send2); auto vote2 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_min * 2, 0, std::vector{ send2->hash () })); node1.vote_processor.vote_blocking (vote2, channel); @@ -856,11 +1236,19 @@ TEST (ledger, successor) nano::system system (1); auto & node1 (*system.nodes[0]); nano::keypair key1; - 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); + nano::block_builder builder; + auto send1 = builder + .send () + .previous (nano::dev::genesis->hash ()) + .destination (key1.pub) + .balance (0) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (0) + .build (); + 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), nano::dev::genesis->hash ()))); + 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), 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))); } @@ -876,10 +1264,17 @@ TEST (ledger, fail_change_old) store->initialize (transaction, ledger.cache, ledger.constants); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; - 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)); + nano::block_builder builder; + auto block = builder + .change () + .previous (nano::dev::genesis->hash ()) + .representative (key1.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); + auto result1 (ledger.process (transaction, *block)); ASSERT_EQ (nano::process_result::progress, result1.code); - auto result2 (ledger.process (transaction, block)); + auto result2 (ledger.process (transaction, *block)); ASSERT_EQ (nano::process_result::old, result2.code); } @@ -894,8 +1289,15 @@ TEST (ledger, fail_change_gap_previous) store->initialize (transaction, ledger.cache, ledger.constants); 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))); - auto result1 (ledger.process (transaction, block)); + nano::block_builder builder; + auto block = builder + .change () + .previous (1) + .representative (key1.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::root (1))) + .build (); + auto result1 (ledger.process (transaction, *block)); ASSERT_EQ (nano::process_result::gap_previous, result1.code); } @@ -910,8 +1312,15 @@ TEST (ledger, fail_change_bad_signature) store->initialize (transaction, ledger.cache, ledger.constants); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; - 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)); + nano::block_builder builder; + auto block = builder + .change () + .previous (nano::dev::genesis->hash ()) + .representative (key1.pub) + .sign (nano::keypair ().prv, 0) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); + auto result1 (ledger.process (transaction, *block)); ASSERT_EQ (nano::process_result::bad_signature, result1.code); } @@ -926,12 +1335,25 @@ TEST (ledger, fail_change_fork) store->initialize (transaction, ledger.cache, ledger.constants); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; - 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)); + nano::block_builder builder; + auto block1 = builder + .change () + .previous (nano::dev::genesis->hash ()) + .representative (key1.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); + auto result1 (ledger.process (transaction, *block1)); ASSERT_EQ (nano::process_result::progress, result1.code); nano::keypair key2; - 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)); + auto block2 = builder + .change () + .previous (nano::dev::genesis->hash ()) + .representative (key2.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); + auto result2 (ledger.process (transaction, *block2)); ASSERT_EQ (nano::process_result::fork, result2.code); } @@ -946,10 +1368,18 @@ TEST (ledger, fail_send_old) store->initialize (transaction, ledger.cache, ledger.constants); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; - 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)); + nano::block_builder builder; + auto block = builder + .send () + .previous (nano::dev::genesis->hash ()) + .destination (key1.pub) + .balance (1) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); + auto result1 (ledger.process (transaction, *block)); ASSERT_EQ (nano::process_result::progress, result1.code); - auto result2 (ledger.process (transaction, block)); + auto result2 (ledger.process (transaction, *block)); ASSERT_EQ (nano::process_result::old, result2.code); } @@ -964,8 +1394,16 @@ TEST (ledger, fail_send_gap_previous) store->initialize (transaction, ledger.cache, ledger.constants); 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))); - auto result1 (ledger.process (transaction, block)); + nano::block_builder builder; + auto block = builder + .send () + .previous (1) + .destination (key1.pub) + .balance (1) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::root (1))) + .build (); + auto result1 (ledger.process (transaction, *block)); ASSERT_EQ (nano::process_result::gap_previous, result1.code); } @@ -980,8 +1418,16 @@ TEST (ledger, fail_send_bad_signature) store->initialize (transaction, ledger.cache, ledger.constants); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; - 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)); + nano::block_builder builder; + auto block = builder + .send () + .previous (nano::dev::genesis->hash ()) + .destination (key1.pub) + .balance (1) + .sign (nano::keypair ().prv, 0) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); + auto result1 (ledger.process (transaction, *block)); ASSERT_EQ (nano::process_result::bad_signature, result1.code); } @@ -996,11 +1442,26 @@ TEST (ledger, fail_send_negative_spend) store->initialize (transaction, ledger.cache, ledger.constants); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; - 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::block_builder builder; + auto block1 = builder + .send () + .previous (nano::dev::genesis->hash ()) + .destination (key1.pub) + .balance (1) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); + 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 ())); - ASSERT_EQ (nano::process_result::negative_spend, ledger.process (transaction, block2).code); + auto block2 = builder + .send () + .previous (block1->hash ()) + .destination (key2.pub) + .balance (2) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (block1->hash ())) + .build (); + ASSERT_EQ (nano::process_result::negative_spend, ledger.process (transaction, *block2).code); } TEST (ledger, fail_send_fork) @@ -1014,11 +1475,26 @@ TEST (ledger, fail_send_fork) store->initialize (transaction, ledger.cache, ledger.constants); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; - 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::block_builder builder; + auto block1 = builder + .send () + .previous (nano::dev::genesis->hash ()) + .destination (key1.pub) + .balance (1) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *block1).code); nano::keypair key2; - 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); + auto block2 = builder + .send () + .previous (nano::dev::genesis->hash ()) + .destination (key2.pub) + .balance (1) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); + ASSERT_EQ (nano::process_result::fork, ledger.process (transaction, *block2).code); } TEST (ledger, fail_open_old) @@ -1032,11 +1508,26 @@ TEST (ledger, fail_open_old) store->initialize (transaction, ledger.cache, ledger.constants); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; - 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); - ASSERT_EQ (nano::process_result::old, ledger.process (transaction, block2).code); + nano::block_builder builder; + auto block1 = builder + .send () + .previous (nano::dev::genesis->hash ()) + .destination (key1.pub) + .balance (1) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *block1).code); + auto block2 = builder + .open () + .source (block1->hash ()) + .representative (1) + .account (key1.pub) + .sign (key1.prv, key1.pub) + .work (*pool.generate (key1.pub)) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *block2).code); + ASSERT_EQ (nano::process_result::old, ledger.process (transaction, *block2).code); } TEST (ledger, fail_open_gap_source) @@ -1050,8 +1541,16 @@ TEST (ledger, fail_open_gap_source) store->initialize (transaction, ledger.cache, ledger.constants); 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)); + nano::block_builder builder; + auto block2 = builder + .open () + .source (1) + .representative (1) + .account (key1.pub) + .sign (key1.prv, key1.pub) + .work (*pool.generate (key1.pub)) + .build (); + auto result2 (ledger.process (transaction, *block2)); ASSERT_EQ (nano::process_result::gap_source, result2.code); } @@ -1066,11 +1565,26 @@ TEST (ledger, fail_open_bad_signature) store->initialize (transaction, ledger.cache, ledger.constants); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; - 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 (); - ASSERT_EQ (nano::process_result::bad_signature, ledger.process (transaction, block2).code); + nano::block_builder builder; + auto block1 = builder + .send () + .previous (nano::dev::genesis->hash ()) + .destination (key1.pub) + .balance (1) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *block1).code); + auto block2 = builder + .open () + .source (block1->hash ()) + .representative (1) + .account (key1.pub) + .sign (key1.prv, key1.pub) + .work (*pool.generate (key1.pub)) + .build (); + block2->signature.clear (); + ASSERT_EQ (nano::process_result::bad_signature, ledger.process (transaction, *block2).code); } TEST (ledger, fail_open_fork_previous) @@ -1084,14 +1598,43 @@ TEST (ledger, fail_open_fork_previous) store->initialize (transaction, ledger.cache, ledger.constants); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; - 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 ())); - 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); + nano::block_builder builder; + auto block1 = builder + .send () + .previous (nano::dev::genesis->hash ()) + .destination (key1.pub) + .balance (1) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *block1).code); + auto block2 = builder + .send () + .previous (block1->hash ()) + .destination (key1.pub) + .balance (0) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (block1->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *block2).code); + auto block3 = builder + .open () + .source (block1->hash ()) + .representative (1) + .account (key1.pub) + .sign (key1.prv, key1.pub) + .work (*pool.generate (key1.pub)) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *block3).code); + auto block4 = builder + .open () + .source (block2->hash ()) + .representative (1) + .account (key1.pub) + .sign (key1.prv, key1.pub) + .work (*pool.generate (key1.pub)) + .build (); + ASSERT_EQ (nano::process_result::fork, ledger.process (transaction, *block4).code); ASSERT_EQ (store->account.count (transaction), ledger.cache.account_count); } @@ -1106,11 +1649,26 @@ TEST (ledger, fail_open_account_mismatch) store->initialize (transaction, ledger.cache, ledger.constants); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; - 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::block_builder builder; + auto block1 = builder + .send () + .previous (nano::dev::genesis->hash ()) + .destination (key1.pub) + .balance (1) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); + 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); + auto block2 = builder + .open () + .source (block1->hash ()) + .representative (1) + .account (badkey.pub) + .sign (badkey.prv, badkey.pub) + .work (*pool.generate (badkey.pub)) + .build (); + ASSERT_NE (nano::process_result::progress, ledger.process (transaction, *block2).code); ASSERT_EQ (store->account.count (transaction), ledger.cache.account_count); } @@ -1125,15 +1683,43 @@ TEST (ledger, fail_receive_old) store->initialize (transaction, ledger.cache, ledger.constants); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; - 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 ())); - 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::receive_block block4 (block3.hash (), block2.hash (), key1.prv, key1.pub, *pool.generate (block3.hash ())); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block4).code); - ASSERT_EQ (nano::process_result::old, ledger.process (transaction, block4).code); + nano::block_builder builder; + auto block1 = builder + .send () + .previous (nano::dev::genesis->hash ()) + .destination (key1.pub) + .balance (1) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *block1).code); + auto block2 = builder + .send () + .previous (block1->hash ()) + .destination (key1.pub) + .balance (0) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (block1->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *block2).code); + auto block3 = builder + .open () + .source (block1->hash ()) + .representative (1) + .account (key1.pub) + .sign (key1.prv, key1.pub) + .work (*pool.generate (key1.pub)) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *block3).code); + auto block4 = builder + .receive () + .previous (block3->hash ()) + .source (block2->hash ()) + .sign (key1.prv, key1.pub) + .work (*pool.generate (block3->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *block4).code); + ASSERT_EQ (nano::process_result::old, ledger.process (transaction, *block4).code); } TEST (ledger, fail_receive_gap_source) @@ -1147,17 +1733,45 @@ TEST (ledger, fail_receive_gap_source) store->initialize (transaction, ledger.cache, ledger.constants); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; - 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)); + nano::block_builder builder; + auto block1 = builder + .send () + .previous (nano::dev::genesis->hash ()) + .destination (key1.pub) + .balance (1) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); + 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 ())); - auto result2 (ledger.process (transaction, block2)); + auto block2 = builder + .send () + .previous (block1->hash ()) + .destination (key1.pub) + .balance (0) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (block1->hash ())) + .build (); + 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)); - auto result3 (ledger.process (transaction, block3)); + auto block3 = builder + .open () + .source (block1->hash ()) + .representative (1) + .account (key1.pub) + .sign (key1.prv, key1.pub) + .work (*pool.generate (key1.pub)) + .build (); + auto result3 (ledger.process (transaction, *block3)); ASSERT_EQ (nano::process_result::progress, result3.code); - nano::receive_block block4 (block3.hash (), 1, key1.prv, key1.pub, *pool.generate (block3.hash ())); - auto result4 (ledger.process (transaction, block4)); + auto block4 = builder + .receive () + .previous (block3->hash ()) + .source (1) + .sign (key1.prv, key1.pub) + .work (*pool.generate (block3->hash ())) + .build (); + auto result4 (ledger.process (transaction, *block4)); ASSERT_EQ (nano::process_result::gap_source, result4.code); } @@ -1172,14 +1786,35 @@ TEST (ledger, fail_receive_overreceive) store->initialize (transaction, ledger.cache, ledger.constants); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; - 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)); + nano::block_builder builder; + auto block1 = builder + .send () + .previous (nano::dev::genesis->hash ()) + .destination (key1.pub) + .balance (1) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); + 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)); - auto result3 (ledger.process (transaction, block2)); + auto block2 = builder + .open () + .source (block1->hash ()) + .representative (1) + .account (key1.pub) + .sign (key1.prv, key1.pub) + .work (*pool.generate (key1.pub)) + .build (); + auto result3 (ledger.process (transaction, *block2)); ASSERT_EQ (nano::process_result::progress, result3.code); - nano::receive_block block3 (block2.hash (), block1.hash (), key1.prv, key1.pub, *pool.generate (block2.hash ())); - auto result4 (ledger.process (transaction, block3)); + auto block3 = builder + .receive () + .previous (block2->hash ()) + .source (block1->hash ()) + .sign (key1.prv, key1.pub) + .work (*pool.generate (block2->hash ())) + .build (); + auto result4 (ledger.process (transaction, *block3)); ASSERT_EQ (nano::process_result::unreceivable, result4.code); } @@ -1194,17 +1829,45 @@ TEST (ledger, fail_receive_bad_signature) store->initialize (transaction, ledger.cache, ledger.constants); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; - 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)); + nano::block_builder builder; + auto block1 = builder + .send () + .previous (nano::dev::genesis->hash ()) + .destination (key1.pub) + .balance (1) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); + 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 ())); - auto result2 (ledger.process (transaction, block2)); + auto block2 = builder + .send () + .previous (block1->hash ()) + .destination (key1.pub) + .balance (0) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (block1->hash ())) + .build (); + 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)); - auto result3 (ledger.process (transaction, block3)); + auto block3 = builder + .open () + .source (block1->hash ()) + .representative (1) + .account (key1.pub) + .sign (key1.prv, key1.pub) + .work (*pool.generate (key1.pub)) + .build (); + auto result3 (ledger.process (transaction, *block3)); ASSERT_EQ (nano::process_result::progress, result3.code); - nano::receive_block block4 (block3.hash (), block2.hash (), nano::keypair ().prv, 0, *pool.generate (block3.hash ())); - auto result4 (ledger.process (transaction, block4)); + auto block4 = builder + .receive () + .previous (block3->hash ()) + .source (block2->hash ()) + .sign (nano::keypair ().prv, 0) + .work (*pool.generate (block3->hash ())) + .build (); + auto result4 (ledger.process (transaction, *block4)); ASSERT_EQ (nano::process_result::bad_signature, result4.code); } @@ -1219,17 +1882,45 @@ TEST (ledger, fail_receive_gap_previous_opened) store->initialize (transaction, ledger.cache, ledger.constants); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; - 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 ())); - 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)); - auto result3 (ledger.process (transaction, block3)); + nano::block_builder builder; + auto block1 = builder + .send () + .previous (nano::dev::genesis->hash ()) + .destination (key1.pub) + .balance (1) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); + auto result1 (ledger.process (transaction, *block1)); + ASSERT_EQ (nano::process_result::progress, result1.code); + auto block2 = builder + .send () + .previous (block1->hash ()) + .destination (key1.pub) + .balance (0) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (block1->hash ())) + .build (); + auto result2 (ledger.process (transaction, *block2)); + ASSERT_EQ (nano::process_result::progress, result2.code); + auto block3 = builder + .open () + .source (block1->hash ()) + .representative (1) + .account (key1.pub) + .sign (key1.prv, key1.pub) + .work (*pool.generate (key1.pub)) + .build (); + auto result3 (ledger.process (transaction, *block3)); ASSERT_EQ (nano::process_result::progress, result3.code); - nano::receive_block block4 (1, block2.hash (), key1.prv, key1.pub, *pool.generate (nano::root (1))); - auto result4 (ledger.process (transaction, block4)); + auto block4 = builder + .receive () + .previous (1) + .source (block2->hash ()) + .sign (key1.prv, key1.pub) + .work (*pool.generate (nano::root (1))) + .build (); + auto result4 (ledger.process (transaction, *block4)); ASSERT_EQ (nano::process_result::gap_previous, result4.code); } @@ -1244,14 +1935,35 @@ TEST (ledger, fail_receive_gap_previous_unopened) store->initialize (transaction, ledger.cache, ledger.constants); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; - 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)); + nano::block_builder builder; + auto block1 = builder + .send () + .previous (nano::dev::genesis->hash ()) + .destination (key1.pub) + .balance (1) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); + 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 ())); - auto result2 (ledger.process (transaction, block2)); + auto block2 = builder + .send () + .previous (block1->hash ()) + .destination (key1.pub) + .balance (0) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (block1->hash ())) + .build (); + 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))); - auto result3 (ledger.process (transaction, block3)); + auto block3 = builder + .receive () + .previous (1) + .source (block2->hash ()) + .sign (key1.prv, key1.pub) + .work (*pool.generate (nano::root (1))) + .build (); + auto result3 (ledger.process (transaction, *block3)); ASSERT_EQ (nano::process_result::gap_previous, result3.code); } @@ -1266,21 +1978,56 @@ TEST (ledger, fail_receive_fork_previous) store->initialize (transaction, ledger.cache, ledger.constants); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; - 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)); + nano::block_builder builder; + auto block1 = builder + .send () + .previous (nano::dev::genesis->hash ()) + .destination (key1.pub) + .balance (1) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); + 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 ())); - auto result2 (ledger.process (transaction, block2)); + auto block2 = builder + .send () + .previous (block1->hash ()) + .destination (key1.pub) + .balance (0) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (block1->hash ())) + .build (); + 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)); - auto result3 (ledger.process (transaction, block3)); + auto block3 = builder + .open () + .source (block1->hash ()) + .representative (1) + .account (key1.pub) + .sign (key1.prv, key1.pub) + .work (*pool.generate (key1.pub)) + .build (); + auto result3 (ledger.process (transaction, *block3)); ASSERT_EQ (nano::process_result::progress, result3.code); nano::keypair key2; - nano::send_block block4 (block3.hash (), key1.pub, 1, key1.prv, key1.pub, *pool.generate (block3.hash ())); - auto result4 (ledger.process (transaction, block4)); + auto block4 = builder + .send () + .previous (block3->hash ()) + .destination (key1.pub) + .balance (1) + .sign (key1.prv, key1.pub) + .work (*pool.generate (block3->hash ())) + .build (); + auto result4 (ledger.process (transaction, *block4)); ASSERT_EQ (nano::process_result::progress, result4.code); - nano::receive_block block5 (block3.hash (), block2.hash (), key1.prv, key1.pub, *pool.generate (block3.hash ())); - auto result5 (ledger.process (transaction, block5)); + auto block5 = builder + .receive () + .previous (block3->hash ()) + .source (block2->hash ()) + .sign (key1.prv, key1.pub) + .work (*pool.generate (block3->hash ())) + .build (); + auto result5 (ledger.process (transaction, *block5)); ASSERT_EQ (nano::process_result::fork, result5.code); } @@ -1295,27 +2042,75 @@ TEST (ledger, fail_receive_received_source) store->initialize (transaction, ledger.cache, ledger.constants); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; - 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)); + nano::block_builder builder; + auto block1 = builder + .send () + .previous (nano::dev::genesis->hash ()) + .destination (key1.pub) + .balance (2) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); + 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 ())); - auto result2 (ledger.process (transaction, block2)); + auto block2 = builder + .send () + .previous (block1->hash ()) + .destination (key1.pub) + .balance (1) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (block1->hash ())) + .build (); + 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 ())); - auto result6 (ledger.process (transaction, block6)); + auto block6 = builder + .send () + .previous (block2->hash ()) + .destination (key1.pub) + .balance (0) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (block2->hash ())) + .build (); + 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)); - auto result3 (ledger.process (transaction, block3)); + auto block3 = builder + .open () + .source (block1->hash ()) + .representative (1) + .account (key1.pub) + .sign (key1.prv, key1.pub) + .work (*pool.generate (key1.pub)) + .build (); + auto result3 (ledger.process (transaction, *block3)); ASSERT_EQ (nano::process_result::progress, result3.code); nano::keypair key2; - nano::send_block block4 (block3.hash (), key1.pub, 1, key1.prv, key1.pub, *pool.generate (block3.hash ())); - auto result4 (ledger.process (transaction, block4)); + auto block4 = builder + .send () + .previous (block3->hash ()) + .destination (key1.pub) + .balance (1) + .sign (key1.prv, key1.pub) + .work (*pool.generate (block3->hash ())) + .build (); + auto result4 (ledger.process (transaction, *block4)); ASSERT_EQ (nano::process_result::progress, result4.code); - nano::receive_block block5 (block4.hash (), block2.hash (), key1.prv, key1.pub, *pool.generate (block4.hash ())); - auto result5 (ledger.process (transaction, block5)); + auto block5 = builder + .receive () + .previous (block4->hash ()) + .source (block2->hash ()) + .sign (key1.prv, key1.pub) + .work (*pool.generate (block4->hash ())) + .build (); + auto result5 (ledger.process (transaction, *block5)); ASSERT_EQ (nano::process_result::progress, result5.code); - nano::receive_block block7 (block3.hash (), block2.hash (), key1.prv, key1.pub, *pool.generate (block3.hash ())); - auto result7 (ledger.process (transaction, block7)); + auto block7 = builder + .receive () + .previous (block3->hash ()) + .source (block2->hash ()) + .sign (key1.prv, key1.pub) + .work (*pool.generate (block3->hash ())) + .build (); + auto result7 (ledger.process (transaction, *block7)); ASSERT_EQ (nano::process_result::fork, result7.code); } @@ -1345,9 +2140,17 @@ TEST (ledger, latest_root) 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)); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send).code); - ASSERT_EQ (send.hash (), ledger.latest_root (transaction, nano::dev::genesis_key.pub)); + nano::block_builder builder; + auto send = builder + .send () + .previous (hash1) + .destination (0) + .balance (1) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (hash1)) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send).code); + ASSERT_EQ (send->hash (), ledger.latest_root (transaction, nano::dev::genesis_key.pub)); } TEST (ledger, change_representative_move_representation) @@ -1362,15 +2165,36 @@ TEST (ledger, change_representative_move_representation) store->initialize (transaction, ledger.cache, ledger.constants); 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); + nano::block_builder builder; + auto send = builder + .send () + .previous (nano::dev::genesis->hash ()) + .destination (key1.pub) + .balance (0) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send).code); 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 ())); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, change).code); + auto change = builder + .change () + .previous (send->hash ()) + .representative (key2.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (send->hash ())) + .build (); + 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); + auto open = builder + .open () + .source (send->hash ()) + .representative (key3.pub) + .account (key1.pub) + .sign (key1.prv, key1.pub) + .work (*pool.generate (key1.pub)) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *open).code); ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.weight (key3.pub)); } @@ -1387,46 +2211,80 @@ TEST (ledger, send_open_receive_rollback) nano::account_info 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::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)); + nano::block_builder builder; + auto send1 = builder + .send () + .previous (info1.head) + .destination (key1.pub) + .balance (nano::dev::constants.genesis_amount - 50) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (info1.head)) + .build (); + auto return1 (ledger.process (transaction, *send1)); ASSERT_EQ (nano::process_result::progress, return1.code); - 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)); + auto send2 = builder + .send () + .previous (send1->hash ()) + .destination (key1.pub) + .balance (nano::dev::constants.genesis_amount - 100) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (send1->hash ())) + .build (); + auto return2 (ledger.process (transaction, *send2)); ASSERT_EQ (nano::process_result::progress, return2.code); nano::keypair key2; - nano::open_block open (send2.hash (), key2.pub, key1.pub, key1.prv, key1.pub, *pool.generate (key1.pub)); - auto return4 (ledger.process (transaction, open)); + auto open = builder + .open () + .source (send2->hash ()) + .representative (key2.pub) + .account (key1.pub) + .sign (key1.prv, key1.pub) + .work (*pool.generate (key1.pub)) + .build (); + auto return4 (ledger.process (transaction, *open)); ASSERT_EQ (nano::process_result::progress, return4.code); - nano::receive_block receive (open.hash (), send1.hash (), key1.prv, key1.pub, *pool.generate (open.hash ())); - auto return5 (ledger.process (transaction, receive)); + auto receive = builder + .receive () + .previous (open->hash ()) + .source (send1->hash ()) + .sign (key1.prv, key1.pub) + .work (*pool.generate (open->hash ())) + .build (); + auto return5 (ledger.process (transaction, *receive)); ASSERT_EQ (nano::process_result::progress, return5.code); nano::keypair key3; ASSERT_EQ (100, ledger.weight (key2.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 ())); - auto return6 (ledger.process (transaction, change1)); + auto change1 = builder + .change () + .previous (send2->hash ()) + .representative (key3.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (send2->hash ())) + .build (); + 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::dev::constants.genesis_amount - 100, ledger.weight (key3.pub)); - ASSERT_FALSE (ledger.rollback (transaction, receive.hash ())); + 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::dev::constants.genesis_amount - 100, ledger.weight (key3.pub)); - ASSERT_FALSE (ledger.rollback (transaction, open.hash ())); + 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::dev::constants.genesis_amount - 100, ledger.weight (key3.pub)); - ASSERT_FALSE (ledger.rollback (transaction, change1.hash ())); + ASSERT_FALSE (ledger.rollback (transaction, change1->hash ())); ASSERT_EQ (0, ledger.weight (key2.pub)); ASSERT_EQ (0, ledger.weight (key3.pub)); ASSERT_EQ (nano::dev::constants.genesis_amount - 100, ledger.weight (nano::dev::genesis_key.pub)); - ASSERT_FALSE (ledger.rollback (transaction, send2.hash ())); + ASSERT_FALSE (ledger.rollback (transaction, send2->hash ())); ASSERT_EQ (0, ledger.weight (key2.pub)); ASSERT_EQ (0, ledger.weight (key3.pub)); ASSERT_EQ (nano::dev::constants.genesis_amount - 50, ledger.weight (nano::dev::genesis_key.pub)); - ASSERT_FALSE (ledger.rollback (transaction, send1.hash ())); + ASSERT_FALSE (ledger.rollback (transaction, send1->hash ())); ASSERT_EQ (0, ledger.weight (key2.pub)); ASSERT_EQ (0, ledger.weight (key3.pub)); ASSERT_EQ (nano::dev::constants.genesis_amount - 0, ledger.weight (nano::dev::genesis_key.pub)); @@ -1446,8 +2304,16 @@ TEST (ledger, bootstrap_rep_weight) auto transaction (store->tx_begin_write ()); store->initialize (transaction, ledger.cache, ledger.constants); 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); + nano::block_builder builder; + auto send = builder + .send () + .previous (info1.head) + .destination (key2.pub) + .balance (std::numeric_limits::max () - 50) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (info1.head)) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send).code); } ASSERT_EQ (2, ledger.cache.block_count); { @@ -1458,8 +2324,16 @@ 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_EQ (nano::process_result::progress, ledger.process (transaction, send).code); + nano::block_builder builder; + auto send = builder + .send () + .previous (info1.head) + .destination (key2.pub) + .balance (std::numeric_limits::max () - 100) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (info1.head)) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send).code); } ASSERT_EQ (3, ledger.cache.block_count); { @@ -1481,36 +2355,84 @@ TEST (ledger, block_destination_source) nano::keypair dest; nano::uint128_t balance (nano::dev::constants.genesis_amount); balance -= nano::Gxrb_ratio; - 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 ())); + nano::block_builder builder; + auto block1 = builder + .send () + .previous (nano::dev::genesis->hash ()) + .destination (dest.pub) + .balance (balance) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); balance -= nano::Gxrb_ratio; - 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 ())); + auto block2 = builder + .send () + .previous (block1->hash ()) + .destination (nano::dev::genesis->account ()) + .balance (balance) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (block1->hash ())) + .build (); balance += nano::Gxrb_ratio; - nano::receive_block block3 (block2.hash (), block2.hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (block2.hash ())); + auto block3 = builder + .receive () + .previous (block2->hash ()) + .source (block2->hash ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (block2->hash ())) + .build (); balance -= nano::Gxrb_ratio; - 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 ())); + auto block4 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (block3->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (balance) + .link (dest.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (block3->hash ())) + .build (); balance -= nano::Gxrb_ratio; - 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 ())); + auto block5 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (block4->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (balance) + .link (nano::dev::genesis->account ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (block4->hash ())) + .build (); balance += nano::Gxrb_ratio; - 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); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block4).code); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block5).code); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block6).code); - ASSERT_EQ (balance, ledger.balance (transaction, block6.hash ())); - ASSERT_EQ (dest.pub, ledger.block_destination (transaction, block1)); - ASSERT_TRUE (ledger.block_source (transaction, block1).is_zero ()); - ASSERT_EQ (nano::dev::genesis->account (), ledger.block_destination (transaction, block2)); - ASSERT_TRUE (ledger.block_source (transaction, block2).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::dev::genesis->account (), ledger.block_destination (transaction, block5)); - ASSERT_TRUE (ledger.block_source (transaction, block5).is_zero ()); - ASSERT_TRUE (ledger.block_destination (transaction, block6) == nullptr); - ASSERT_EQ (block5.hash (), ledger.block_source (transaction, block6)); + auto block6 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (block5->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (balance) + .link (block5->hash ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (block5->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *block1).code); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *block2).code); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *block3).code); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *block4).code); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *block5).code); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *block6).code); + ASSERT_EQ (balance, ledger.balance (transaction, block6->hash ())); + ASSERT_EQ (dest.pub, ledger.block_destination (transaction, *block1)); + ASSERT_TRUE (ledger.block_source (transaction, *block1).is_zero ()); + ASSERT_EQ (nano::dev::genesis->account (), ledger.block_destination (transaction, *block2)); + ASSERT_TRUE (ledger.block_source (transaction, *block2).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::dev::genesis->account (), ledger.block_destination (transaction, *block5)); + ASSERT_TRUE (ledger.block_source (transaction, *block5).is_zero ()); + ASSERT_TRUE (ledger.block_destination (transaction, *block6) == nullptr); + ASSERT_EQ (block5->hash (), ledger.block_source (transaction, *block6)); } TEST (ledger, state_account) @@ -1523,9 +2445,19 @@ TEST (ledger, state_account) auto transaction (store->tx_begin_write ()); store->initialize (transaction, ledger.cache, ledger.constants); 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::Gxrb_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::dev::genesis->account (), ledger.account (transaction, send1.hash ())); + nano::block_builder builder; + auto send1 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .link (nano::dev::genesis->account ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); + ASSERT_EQ (nano::dev::genesis->account (), ledger.account (transaction, send1->hash ())); } TEST (ledger, state_send_receive) @@ -1538,30 +2470,49 @@ TEST (ledger, state_send_receive) auto transaction (store->tx_begin_write ()); store->initialize (transaction, ledger.cache, ledger.constants); 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::Gxrb_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 ())); + nano::block_builder builder; + auto send1 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .link (nano::dev::genesis->account ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); + ASSERT_TRUE (store->block.exists (transaction, send1->hash ())); + auto send2 (store->block.get (transaction, send1->hash ())); ASSERT_NE (nullptr, send2); - ASSERT_EQ (send1, *send2); - ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.balance (transaction, send1.hash ())); - ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, send1.hash ())); + ASSERT_EQ (*send1, *send2); + ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.balance (transaction, send1->hash ())); + ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, send1->hash ())); ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::dev::genesis->account ())); - ASSERT_TRUE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send1.hash ()))); + 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::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 ())); + auto receive1 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (send1->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount) + .link (send1->hash ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (send1->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *receive1).code); + ASSERT_TRUE (store->block.exists (transaction, receive1->hash ())); + auto receive2 (store->block.get (transaction, receive1->hash ())); ASSERT_NE (nullptr, receive2); - ASSERT_EQ (receive1, *receive2); - ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.balance (transaction, receive1.hash ())); - ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, receive1.hash ())); + ASSERT_EQ (*receive1, *receive2); + ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.balance (transaction, receive1->hash ())); + ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, receive1->hash ())); 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_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); @@ -1579,23 +2530,40 @@ TEST (ledger, state_receive) auto transaction (store->tx_begin_write ()); store->initialize (transaction, ledger.cache, ledger.constants); 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::Gxrb_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 ())); + nano::block_builder builder; + auto send1 = builder + .send () + .previous (nano::dev::genesis->hash ()) + .destination (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); + ASSERT_TRUE (store->block.exists (transaction, send1->hash ())); + auto send2 (store->block.get (transaction, send1->hash ())); ASSERT_NE (nullptr, send2); - ASSERT_EQ (send1, *send2); - ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.balance (transaction, send1.hash ())); - ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, send1.hash ())); + ASSERT_EQ (*send1, *send2); + ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.balance (transaction, send1->hash ())); + ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, send1->hash ())); ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_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 ())); + auto receive1 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (send1->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount) + .link (send1->hash ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (send1->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *receive1).code); + ASSERT_TRUE (store->block.exists (transaction, receive1->hash ())); + auto receive2 (store->block.get (transaction, receive1->hash ())); ASSERT_NE (nullptr, receive2); - ASSERT_EQ (receive1, *receive2); - ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.balance (transaction, receive1.hash ())); - ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, receive1.hash ())); + ASSERT_EQ (*receive1, *receive2); + ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.balance (transaction, receive1->hash ())); + ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, receive1->hash ())); 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); @@ -1614,14 +2582,24 @@ TEST (ledger, state_rep_change) store->initialize (transaction, ledger.cache, ledger.constants); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair rep; - 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 ())); + nano::block_builder builder; + auto change1 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (nano::dev::genesis->hash ()) + .representative (rep.pub) + .balance (nano::dev::constants.genesis_amount) + .link (0) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *change1).code); + ASSERT_TRUE (store->block.exists (transaction, change1->hash ())); + auto change2 (store->block.get (transaction, change1->hash ())); ASSERT_NE (nullptr, change2); - ASSERT_EQ (change1, *change2); - ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.balance (transaction, change1.hash ())); - ASSERT_EQ (0, ledger.amount (transaction, change1.hash ())); + ASSERT_EQ (*change1, *change2); + 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::dev::genesis->account ())); ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.weight (rep.pub)); ASSERT_EQ (2, change2->sideband ().height); @@ -1641,25 +2619,44 @@ TEST (ledger, state_open) store->initialize (transaction, ledger.cache, ledger.constants); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair destination; - nano::state_block send1 (nano::dev::genesis->account (), nano::dev::genesis->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::Gxrb_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 ())); + nano::block_builder builder; + auto send1 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .link (destination.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); + ASSERT_TRUE (store->block.exists (transaction, send1->hash ())); + auto send2 (store->block.get (transaction, send1->hash ())); ASSERT_NE (nullptr, send2); - ASSERT_EQ (send1, *send2); - ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.balance (transaction, send1.hash ())); - ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, send1.hash ())); + ASSERT_EQ (*send1, *send2); + ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.balance (transaction, send1->hash ())); + ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, send1->hash ())); ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_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::Gxrb_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_TRUE (store->pending.exists (transaction, nano::pending_key (destination.pub, send1->hash ()))); + auto open1 = builder + .state () + .account (destination.pub) + .previous (0) + .representative (nano::dev::genesis->account ()) + .balance (nano::Gxrb_ratio) + .link (send1->hash ()) + .sign (destination.prv, destination.pub) + .work (*pool.generate (destination.pub)) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *open1).code); + ASSERT_FALSE (store->pending.exists (transaction, nano::pending_key (destination.pub, send1->hash ()))); + ASSERT_TRUE (store->block.exists (transaction, open1->hash ())); + auto open2 (store->block.get (transaction, open1->hash ())); ASSERT_NE (nullptr, open2); - ASSERT_EQ (open1, *open2); - ASSERT_EQ (nano::Gxrb_ratio, ledger.balance (transaction, open1.hash ())); - ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, open1.hash ())); + ASSERT_EQ (*open1, *open2); + ASSERT_EQ (nano::Gxrb_ratio, ledger.balance (transaction, open1->hash ())); + ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, open1->hash ())); ASSERT_EQ (nano::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); @@ -1679,10 +2676,27 @@ TEST (ledger, send_after_state_fail) auto transaction (store->tx_begin_write ()); store->initialize (transaction, ledger.cache, ledger.constants); 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::Gxrb_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::dev::genesis->account (), nano::dev::constants.genesis_amount - (2 * nano::Gxrb_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); + nano::block_builder builder; + auto send1 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .link (nano::dev::genesis->account ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); + auto send2 = builder + .send () + .previous (send1->hash ()) + .destination (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - (2 * nano::Gxrb_ratio)) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (send1->hash ())) + .build (); + ASSERT_EQ (nano::process_result::block_position, ledger.process (transaction, *send2).code); } // Make sure old block types can't be inserted after a state block. @@ -1696,10 +2710,26 @@ TEST (ledger, receive_after_state_fail) auto transaction (store->tx_begin_write ()); store->initialize (transaction, ledger.cache, ledger.constants); 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::Gxrb_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 ())); - ASSERT_EQ (nano::process_result::block_position, ledger.process (transaction, receive1).code); + nano::block_builder builder; + auto send1 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .link (nano::dev::genesis->account ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); + auto receive1 = builder + .receive () + .previous (send1->hash ()) + .source (send1->hash ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (send1->hash ())) + .build (); + ASSERT_EQ (nano::process_result::block_position, ledger.process (transaction, *receive1).code); } // Make sure old block types can't be inserted after a state block. @@ -1713,11 +2743,27 @@ TEST (ledger, change_after_state_fail) auto transaction (store->tx_begin_write ()); store->initialize (transaction, ledger.cache, ledger.constants); 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::Gxrb_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::block_builder builder; + auto send1 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .link (nano::dev::genesis->account ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); + 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 ())); - ASSERT_EQ (nano::process_result::block_position, ledger.process (transaction, change1).code); + auto change1 = builder + .change () + .previous (send1->hash ()) + .representative (rep.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (send1->hash ())) + .build (); + ASSERT_EQ (nano::process_result::block_position, ledger.process (transaction, *change1).code); } TEST (ledger, state_unreceivable_fail) @@ -1730,17 +2776,34 @@ TEST (ledger, state_unreceivable_fail) auto transaction (store->tx_begin_write ()); store->initialize (transaction, ledger.cache, ledger.constants); 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::Gxrb_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 ())); + nano::block_builder builder; + auto send1 = builder + .send () + .previous (nano::dev::genesis->hash ()) + .destination (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); + ASSERT_TRUE (store->block.exists (transaction, send1->hash ())); + auto send2 (store->block.get (transaction, send1->hash ())); ASSERT_NE (nullptr, send2); - ASSERT_EQ (send1, *send2); - ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.balance (transaction, send1.hash ())); - ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, send1.hash ())); + ASSERT_EQ (*send1, *send2); + ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.balance (transaction, send1->hash ())); + ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, send1->hash ())); ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_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); + auto receive1 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (send1->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount) + .link (1) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (send1->hash ())) + .build (); + ASSERT_EQ (nano::process_result::gap_source, ledger.process (transaction, *receive1).code); } TEST (ledger, state_receive_bad_amount_fail) @@ -1753,17 +2816,34 @@ TEST (ledger, state_receive_bad_amount_fail) auto transaction (store->tx_begin_write ()); store->initialize (transaction, ledger.cache, ledger.constants); 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::Gxrb_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 ())); + nano::block_builder builder; + auto send1 = builder + .send () + .previous (nano::dev::genesis->hash ()) + .destination (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); + ASSERT_TRUE (store->block.exists (transaction, send1->hash ())); + auto send2 (store->block.get (transaction, send1->hash ())); ASSERT_NE (nullptr, send2); - ASSERT_EQ (send1, *send2); - ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.balance (transaction, send1.hash ())); - ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, send1.hash ())); + ASSERT_EQ (*send1, *send2); + ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.balance (transaction, send1->hash ())); + ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, send1->hash ())); ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_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::Gxrb_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); + auto receive1 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (send1->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .link (send1->hash ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (send1->hash ())) + .build (); + ASSERT_EQ (nano::process_result::balance_mismatch, ledger.process (transaction, *receive1).code); } TEST (ledger, state_no_link_amount_fail) @@ -1776,11 +2856,30 @@ TEST (ledger, state_no_link_amount_fail) auto transaction (store->tx_begin_write ()); store->initialize (transaction, ledger.cache, ledger.constants); 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::Gxrb_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::block_builder builder; + auto send1 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .link (nano::dev::genesis->account ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); nano::keypair rep; - 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); + auto change1 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (send1->hash ()) + .representative (rep.pub) + .balance (nano::dev::constants.genesis_amount) + .link (0) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (send1->hash ())) + .build (); + ASSERT_EQ (nano::process_result::balance_mismatch, ledger.process (transaction, *change1).code); } TEST (ledger, state_receive_wrong_account_fail) @@ -1793,18 +2892,37 @@ TEST (ledger, state_receive_wrong_account_fail) auto transaction (store->tx_begin_write ()); store->initialize (transaction, ledger.cache, ledger.constants); 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::Gxrb_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 ())); + nano::block_builder builder; + auto send1 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .link (nano::dev::genesis->account ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); + ASSERT_TRUE (store->block.exists (transaction, send1->hash ())); + auto send2 (store->block.get (transaction, send1->hash ())); ASSERT_NE (nullptr, send2); - ASSERT_EQ (send1, *send2); - ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.balance (transaction, send1.hash ())); - ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, send1.hash ())); + ASSERT_EQ (*send1, *send2); + ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.balance (transaction, send1->hash ())); + ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, send1->hash ())); ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::dev::genesis->account ())); nano::keypair key; - nano::state_block receive1 (key.pub, 0, nano::dev::genesis->account (), nano::Gxrb_ratio, send1.hash (), key.prv, key.pub, *pool.generate (key.pub)); - ASSERT_EQ (nano::process_result::unreceivable, ledger.process (transaction, receive1).code); + auto receive1 = builder + .state () + .account (key.pub) + .previous (0) + .representative (nano::dev::genesis->account ()) + .balance (nano::Gxrb_ratio) + .link (send1->hash ()) + .sign (key.prv, key.pub) + .work (*pool.generate (key.pub)) + .build (); + ASSERT_EQ (nano::process_result::unreceivable, ledger.process (transaction, *receive1).code); } TEST (ledger, state_open_state_fork) @@ -1818,13 +2936,39 @@ TEST (ledger, state_open_state_fork) store->initialize (transaction, ledger.cache, ledger.constants); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair destination; - nano::state_block send1 (nano::dev::genesis->account (), nano::dev::genesis->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::Gxrb_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::dev::genesis->account (), nano::Gxrb_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::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 ()); + nano::block_builder builder; + auto send1 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .link (destination.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); + auto open1 = builder + .state () + .account (destination.pub) + .previous (0) + .representative (nano::dev::genesis->account ()) + .balance (nano::Gxrb_ratio) + .link (send1->hash ()) + .sign (destination.prv, destination.pub) + .work (*pool.generate (destination.pub)) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *open1).code); + auto open2 = builder + .open () + .source (send1->hash ()) + .representative (nano::dev::genesis->account ()) + .account (destination.pub) + .sign (destination.prv, destination.pub) + .work (*pool.generate (destination.pub)) + .build (); + ASSERT_EQ (nano::process_result::fork, ledger.process (transaction, *open2).code); + ASSERT_EQ (open1->root (), open2->root ()); } TEST (ledger, state_state_open_fork) @@ -1838,13 +2982,39 @@ TEST (ledger, state_state_open_fork) store->initialize (transaction, ledger.cache, ledger.constants); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair destination; - nano::state_block send1 (nano::dev::genesis->account (), nano::dev::genesis->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::Gxrb_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::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::dev::genesis->account (), nano::Gxrb_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 ()); + nano::block_builder builder; + auto send1 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .link (destination.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); + auto open1 = builder + .open () + .source (send1->hash ()) + .representative (nano::dev::genesis->account ()) + .account (destination.pub) + .sign (destination.prv, destination.pub) + .work (*pool.generate (destination.pub)) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *open1).code); + auto open2 = builder + .state () + .account (destination.pub) + .previous (0) + .representative (nano::dev::genesis->account ()) + .balance (nano::Gxrb_ratio) + .link (send1->hash ()) + .sign (destination.prv, destination.pub) + .work (*pool.generate (destination.pub)) + .build (); + 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); } @@ -1859,10 +3029,29 @@ TEST (ledger, state_open_previous_fail) store->initialize (transaction, ledger.cache, ledger.constants); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair destination; - nano::state_block send1 (nano::dev::genesis->account (), nano::dev::genesis->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::Gxrb_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::dev::genesis->account (), nano::Gxrb_ratio, send1.hash (), destination.prv, destination.pub, *pool.generate (1)); - ASSERT_EQ (nano::process_result::gap_previous, ledger.process (transaction, open1).code); + nano::block_builder builder; + auto send1 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .link (destination.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); + auto open1 = builder + .state () + .account (destination.pub) + .previous (1) + .representative (nano::dev::genesis->account ()) + .balance (nano::Gxrb_ratio) + .link (send1->hash ()) + .sign (destination.prv, destination.pub) + .work (*pool.generate (1)) + .build (); + ASSERT_EQ (nano::process_result::gap_previous, ledger.process (transaction, *open1).code); } TEST (ledger, state_open_source_fail) @@ -1876,10 +3065,29 @@ TEST (ledger, state_open_source_fail) store->initialize (transaction, ledger.cache, ledger.constants); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair destination; - nano::state_block send1 (nano::dev::genesis->account (), nano::dev::genesis->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::Gxrb_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::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); + nano::block_builder builder; + auto send1 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .link (destination.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); + auto open1 = builder + .state () + .account (destination.pub) + .previous (0) + .representative (nano::dev::genesis->account ()) + .balance (0) + .link (0) + .sign (destination.prv, destination.pub) + .work (*pool.generate (destination.pub)) + .build (); + ASSERT_EQ (nano::process_result::gap_source, ledger.process (transaction, *open1).code); } TEST (ledger, state_send_change) @@ -1893,14 +3101,24 @@ TEST (ledger, state_send_change) store->initialize (transaction, ledger.cache, ledger.constants); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair rep; - nano::state_block send1 (nano::dev::genesis->account (), nano::dev::genesis->hash (), rep.pub, nano::dev::constants.genesis_amount - nano::Gxrb_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 ())); + nano::block_builder builder; + auto send1 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (nano::dev::genesis->hash ()) + .representative (rep.pub) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .link (nano::dev::genesis->account ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); + ASSERT_TRUE (store->block.exists (transaction, send1->hash ())); + auto send2 (store->block.get (transaction, send1->hash ())); ASSERT_NE (nullptr, send2); - ASSERT_EQ (send1, *send2); - ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.balance (transaction, send1.hash ())); - ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, send1.hash ())); + ASSERT_EQ (*send1, *send2); + ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.balance (transaction, send1->hash ())); + ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, send1->hash ())); ASSERT_EQ (0, ledger.weight (nano::dev::genesis->account ())); ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.weight (rep.pub)); ASSERT_EQ (2, send2->sideband ().height); @@ -1919,24 +3137,43 @@ TEST (ledger, state_receive_change) auto transaction (store->tx_begin_write ()); store->initialize (transaction, ledger.cache, ledger.constants); 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::Gxrb_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 ())); + nano::block_builder builder; + auto send1 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .link (nano::dev::genesis->account ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); + ASSERT_TRUE (store->block.exists (transaction, send1->hash ())); + auto send2 (store->block.get (transaction, send1->hash ())); ASSERT_NE (nullptr, send2); - ASSERT_EQ (send1, *send2); - ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.balance (transaction, send1.hash ())); - ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, send1.hash ())); + ASSERT_EQ (*send1, *send2); + ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.balance (transaction, send1->hash ())); + ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, send1->hash ())); ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::dev::genesis->account ())); nano::keypair rep; - 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 ())); + auto receive1 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (send1->hash ()) + .representative (rep.pub) + .balance (nano::dev::constants.genesis_amount) + .link (send1->hash ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (send1->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *receive1).code); + ASSERT_TRUE (store->block.exists (transaction, receive1->hash ())); + auto receive2 (store->block.get (transaction, receive1->hash ())); ASSERT_NE (nullptr, receive2); - ASSERT_EQ (receive1, *receive2); - ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.balance (transaction, receive1.hash ())); - ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, receive1.hash ())); + ASSERT_EQ (*receive1, *receive2); + ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.balance (transaction, receive1->hash ())); + ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, receive1->hash ())); 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); @@ -1956,12 +3193,29 @@ TEST (ledger, state_open_old) store->initialize (transaction, ledger.cache, ledger.constants); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair destination; - nano::state_block send1 (nano::dev::genesis->account (), nano::dev::genesis->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::Gxrb_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::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::Gxrb_ratio, ledger.balance (transaction, open1.hash ())); - ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, open1.hash ())); + nano::block_builder builder; + auto send1 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .link (destination.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); + auto open1 = builder + .open () + .source (send1->hash ()) + .representative (nano::dev::genesis->account ()) + .account (destination.pub) + .sign (destination.prv, destination.pub) + .work (*pool.generate (destination.pub)) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *open1).code); + ASSERT_EQ (nano::Gxrb_ratio, ledger.balance (transaction, open1->hash ())); + ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, open1->hash ())); ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.weight (nano::dev::genesis->account ())); } @@ -1976,16 +3230,48 @@ TEST (ledger, state_receive_old) store->initialize (transaction, ledger.cache, ledger.constants); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair destination; - nano::state_block send1 (nano::dev::genesis->account (), nano::dev::genesis->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::Gxrb_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::dev::genesis->account (), send1.hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - (2 * nano::Gxrb_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::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::Gxrb_ratio, ledger.balance (transaction, receive1.hash ())); - ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, receive1.hash ())); + nano::block_builder builder; + auto send1 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .link (destination.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); + auto send2 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (send1->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - (2 * nano::Gxrb_ratio)) + .link (destination.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (send1->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send2).code); + auto open1 = builder + .open () + .source (send1->hash ()) + .representative (nano::dev::genesis->account ()) + .account (destination.pub) + .sign (destination.prv, destination.pub) + .work (*pool.generate (destination.pub)) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *open1).code); + auto receive1 = builder + .receive () + .previous (open1->hash ()) + .source (send2->hash ()) + .sign (destination.prv, destination.pub) + .work (*pool.generate (open1->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *receive1).code); + ASSERT_EQ (2 * nano::Gxrb_ratio, ledger.balance (transaction, receive1->hash ())); + ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, receive1->hash ())); ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.weight (nano::dev::genesis->account ())); } @@ -1999,23 +3285,33 @@ TEST (ledger, state_rollback_send) auto transaction (store->tx_begin_write ()); store->initialize (transaction, ledger.cache, ledger.constants); 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::Gxrb_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 ())); + nano::block_builder builder; + auto send1 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .link (nano::dev::genesis->account ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); + ASSERT_TRUE (store->block.exists (transaction, send1->hash ())); + auto send2 (store->block.get (transaction, send1->hash ())); ASSERT_NE (nullptr, send2); - ASSERT_EQ (send1, *send2); + ASSERT_EQ (*send1, *send2); ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.account_balance (transaction, nano::dev::genesis->account ())); ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::dev::genesis->account ())); nano::pending_info info; - ASSERT_FALSE (store->pending.get (transaction, nano::pending_key (nano::dev::genesis->account (), send1.hash ()), info)); + 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::Gxrb_ratio, info.amount.number ()); - ASSERT_FALSE (ledger.rollback (transaction, send1.hash ())); - ASSERT_FALSE (store->block.exists (transaction, send1.hash ())); + ASSERT_FALSE (ledger.rollback (transaction, send1->hash ())); + 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_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); } @@ -2030,17 +3326,36 @@ TEST (ledger, state_rollback_receive) auto transaction (store->tx_begin_write ()); store->initialize (transaction, ledger.cache, ledger.constants); 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::Gxrb_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::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::dev::genesis->account (), receive1.hash ()))); - ASSERT_FALSE (ledger.rollback (transaction, receive1.hash ())); + nano::block_builder builder; + auto send1 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .link (nano::dev::genesis->account ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); + auto receive1 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (send1->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount) + .link (send1->hash ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (send1->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *receive1).code); + 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::dev::genesis->account (), send1.hash ()), info)); + 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::Gxrb_ratio, info.amount.number ()); - ASSERT_FALSE (store->block.exists (transaction, receive1.hash ())); + ASSERT_FALSE (store->block.exists (transaction, receive1->hash ())); ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.account_balance (transaction, nano::dev::genesis->account ())); ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::dev::genesis->account ())); ASSERT_EQ (store->account.count (transaction), ledger.cache.account_count); @@ -2057,15 +3372,34 @@ TEST (ledger, state_rollback_received_send) store->initialize (transaction, ledger.cache, ledger.constants); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key; - nano::state_block send1 (nano::dev::genesis->account (), nano::dev::genesis->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::Gxrb_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::Gxrb_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::dev::genesis->account (), receive1.hash ()))); - ASSERT_FALSE (ledger.rollback (transaction, send1.hash ())); - 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 ())); + nano::block_builder builder; + auto send1 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .link (key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); + auto receive1 = builder + .state () + .account (key.pub) + .previous (0) + .representative (key.pub) + .balance (nano::Gxrb_ratio) + .link (send1->hash ()) + .sign (key.prv, key.pub) + .work (*pool.generate (key.pub)) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *receive1).code); + 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::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)); @@ -2084,10 +3418,20 @@ TEST (ledger, state_rep_change_rollback) store->initialize (transaction, ledger.cache, ledger.constants); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair rep; - 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 ())); + nano::block_builder builder; + auto change1 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (nano::dev::genesis->hash ()) + .representative (rep.pub) + .balance (nano::dev::constants.genesis_amount) + .link (0) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); + 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::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)); @@ -2104,16 +3448,35 @@ TEST (ledger, state_open_rollback) store->initialize (transaction, ledger.cache, ledger.constants); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair destination; - nano::state_block send1 (nano::dev::genesis->account (), nano::dev::genesis->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::Gxrb_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::dev::genesis->account (), nano::Gxrb_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 ())); + nano::block_builder builder; + auto send1 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .link (destination.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); + auto open1 = builder + .state () + .account (destination.pub) + .previous (0) + .representative (nano::dev::genesis->account ()) + .balance (nano::Gxrb_ratio) + .link (send1->hash ()) + .sign (destination.prv, destination.pub) + .work (*pool.generate (destination.pub)) + .build (); + 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_EQ (0, ledger.account_balance (transaction, destination.pub)); ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_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_FALSE (store->pending.get (transaction, nano::pending_key (destination.pub, send1->hash ()), info)); ASSERT_EQ (nano::dev::genesis->account (), info.source); ASSERT_EQ (nano::Gxrb_ratio, info.amount.number ()); ASSERT_EQ (store->account.count (transaction), ledger.cache.account_count); @@ -2130,10 +3493,20 @@ TEST (ledger, state_send_change_rollback) store->initialize (transaction, ledger.cache, ledger.constants); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair rep; - nano::state_block send1 (nano::dev::genesis->account (), nano::dev::genesis->hash (), rep.pub, nano::dev::constants.genesis_amount - nano::Gxrb_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 ())); + nano::block_builder builder; + auto send1 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (nano::dev::genesis->hash ()) + .representative (rep.pub) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .link (nano::dev::genesis->account ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); + 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::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)); @@ -2150,13 +3523,32 @@ TEST (ledger, state_receive_change_rollback) auto transaction (store->tx_begin_write ()); store->initialize (transaction, ledger.cache, ledger.constants); 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::Gxrb_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::block_builder builder; + auto send1 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .link (nano::dev::genesis->account ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); nano::keypair rep; - 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 ())); + auto receive1 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (send1->hash ()) + .representative (rep.pub) + .balance (nano::dev::constants.genesis_amount) + .link (send1->hash ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (send1->hash ())) + .build (); + 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::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.account_balance (transaction, nano::dev::genesis->account ())); ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::dev::genesis->account ())); ASSERT_EQ (0, ledger.weight (rep.pub)); @@ -2174,63 +3566,137 @@ TEST (ledger, epoch_blocks_v1_general) store->initialize (transaction, ledger.cache, ledger.constants); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair destination; - 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::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::block_builder builder; + auto epoch1 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount) + .link (ledger.epoch_link (nano::epoch::epoch_1)) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); + 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 + auto epoch2 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (epoch1->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount) + .link (ledger.epoch_link (nano::epoch::epoch_1)) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (epoch1->hash ())) + .build (); + 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::dev::genesis->account (), genesis_info)); ASSERT_EQ (genesis_info.epoch (), nano::epoch::epoch_1); - ASSERT_FALSE (ledger.rollback (transaction, epoch1.hash ())); + ASSERT_FALSE (ledger.rollback (transaction, epoch1->hash ())); 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_EQ (nano::process_result::progress, ledger.process (transaction, *epoch1).code); 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::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::dev::genesis->account (), epoch1.hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::Gxrb_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::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::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)); - 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); - ASSERT_TRUE (epoch4.sideband ().details.is_epoch); - 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::receive_block receive1 (epoch4.hash (), send1.hash (), destination.prv, destination.pub, *pool.generate (epoch4.hash ())); - ASSERT_EQ (nano::process_result::block_position, ledger.process (transaction, receive1).code); - nano::state_block receive2 (destination.pub, epoch4.hash (), destination.pub, nano::Gxrb_ratio, send1.hash (), destination.prv, destination.pub, *pool.generate (epoch4.hash ())); - 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_EQ (0, ledger.balance (transaction, epoch4.hash ())); - ASSERT_EQ (nano::Gxrb_ratio, ledger.balance (transaction, receive2.hash ())); - ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, receive2.hash ())); + ASSERT_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 + auto change1 = builder + .change () + .previous (epoch1->hash ()) + .representative (nano::dev::genesis->account ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (epoch1->hash ())) + .build (); + ASSERT_EQ (nano::process_result::block_position, ledger.process (transaction, *change1).code); + auto send1 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (epoch1->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .link (destination.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (epoch1->hash ())) + .build (); + 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 + auto open1 = builder + .open () + .source (send1->hash ()) + .representative (nano::dev::genesis->account ()) + .account (destination.pub) + .sign (destination.prv, destination.pub) + .work (*pool.generate (destination.pub)) + .build (); + ASSERT_EQ (nano::process_result::unreceivable, ledger.process (transaction, *open1).code); + auto epoch3 = builder + .state () + .account (destination.pub) + .previous (0) + .representative (nano::dev::genesis->account ()) + .balance (0) + .link (ledger.epoch_link (nano::epoch::epoch_1)) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (destination.pub)) + .build (); + ASSERT_EQ (nano::process_result::representative_mismatch, ledger.process (transaction, *epoch3).code); + auto epoch4 = builder + .state () + .account (destination.pub) + .previous (0) + .representative (0) + .balance (0) + .link (ledger.epoch_link (nano::epoch::epoch_1)) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (destination.pub)) + .build (); + 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); + ASSERT_TRUE (epoch4->sideband ().details.is_epoch); + 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 + auto receive1 = builder + .receive () + .previous (epoch4->hash ()) + .source (send1->hash ()) + .sign (destination.prv, destination.pub) + .work (*pool.generate (epoch4->hash ())) + .build (); + ASSERT_EQ (nano::process_result::block_position, ledger.process (transaction, *receive1).code); + auto receive2 = builder + .state () + .account (destination.pub) + .previous (epoch4->hash ()) + .representative (destination.pub) + .balance (nano::Gxrb_ratio) + .link (send1->hash ()) + .sign (destination.prv, destination.pub) + .work (*pool.generate (epoch4->hash ())) + .build (); + 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_EQ (0, ledger.balance (transaction, epoch4->hash ())); + ASSERT_EQ (nano::Gxrb_ratio, ledger.balance (transaction, receive2->hash ())); + ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, receive2->hash ())); ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::dev::genesis->account ())); ASSERT_EQ (nano::Gxrb_ratio, ledger.weight (destination.pub)); - ASSERT_FALSE (receive2.sideband ().details.is_send); - ASSERT_TRUE (receive2.sideband ().details.is_receive); - ASSERT_FALSE (receive2.sideband ().details.is_epoch); + ASSERT_FALSE (receive2->sideband ().details.is_send); + ASSERT_TRUE (receive2->sideband ().details.is_receive); + ASSERT_FALSE (receive2->sideband ().details.is_epoch); } TEST (ledger, epoch_blocks_v2_general) @@ -2244,56 +3710,157 @@ TEST (ledger, epoch_blocks_v2_general) store->initialize (transaction, ledger.cache, ledger.constants); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair destination; - 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 ())); + nano::block_builder builder; + auto epoch1 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount) + .link (ledger.epoch_link (nano::epoch::epoch_2)) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); // 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); + 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::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::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::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); + epoch1 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount) + .link (ledger.epoch_link (nano::epoch::epoch_1)) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (epoch1->work) + .build (); + 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 + auto epoch2 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (epoch1->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount) + .link (ledger.epoch_link (nano::epoch::epoch_2)) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (epoch1->hash ())) + .build (); + 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 + auto epoch3 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (epoch2->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount) + .link (ledger.epoch_link (nano::epoch::epoch_2)) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (epoch2->hash ())) + .build (); + 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::dev::genesis->account (), genesis_info)); ASSERT_EQ (genesis_info.epoch (), nano::epoch::epoch_2); - ASSERT_FALSE (ledger.rollback (transaction, epoch1.hash ())); + ASSERT_FALSE (ledger.rollback (transaction, epoch1->hash ())); 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_EQ (nano::process_result::progress, ledger.process (transaction, *epoch1).code); 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::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::dev::genesis->account (), epoch1.hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::Gxrb_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::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)); - 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::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 ())); - 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 - nano::receive_block receive1 (epoch6.hash (), send1.hash (), destination.prv, destination.pub, *pool.generate (epoch6.hash ())); - ASSERT_EQ (nano::process_result::block_position, ledger.process (transaction, receive1).code); - nano::state_block receive2 (destination.pub, epoch6.hash (), destination.pub, nano::Gxrb_ratio, send1.hash (), destination.prv, destination.pub, *pool.generate (epoch6.hash ())); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, receive2).code); - ASSERT_EQ (nano::epoch::epoch_2, receive2.sideband ().details.epoch); - ASSERT_EQ (nano::epoch::epoch_1, receive2.sideband ().source_epoch); - ASSERT_EQ (0, ledger.balance (transaction, epoch6.hash ())); - ASSERT_EQ (nano::Gxrb_ratio, ledger.balance (transaction, receive2.hash ())); - ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, receive2.hash ())); + auto change1 = builder + .change () + .previous (epoch1->hash ()) + .representative (nano::dev::genesis->account ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (epoch1->hash ())) + .build (); + ASSERT_EQ (nano::process_result::block_position, ledger.process (transaction, *change1).code); + auto send1 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (epoch1->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .link (destination.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (epoch1->hash ())) + .build (); + 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 + auto open1 = builder + .open () + .source (send1->hash ()) + .representative (nano::dev::genesis->account ()) + .account (destination.pub) + .sign (destination.prv, destination.pub) + .work (*pool.generate (destination.pub)) + .build (); + ASSERT_EQ (nano::process_result::unreceivable, ledger.process (transaction, *open1).code); + auto epoch4 = builder + .state () + .account (destination.pub) + .previous (0) + .representative (0) + .balance (0) + .link (ledger.epoch_link (nano::epoch::epoch_1)) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (destination.pub)) + .build (); + 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 + auto epoch5 = builder + .state () + .account (destination.pub) + .previous (epoch4->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (0) + .link (ledger.epoch_link (nano::epoch::epoch_2)) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (epoch4->hash ())) + .build (); + ASSERT_EQ (nano::process_result::representative_mismatch, ledger.process (transaction, *epoch5).code); + auto epoch6 = builder + .state () + .account (destination.pub) + .previous (epoch4->hash ()) + .representative (0) + .balance (0) + .link (ledger.epoch_link (nano::epoch::epoch_2)) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (epoch4->hash ())) + .build (); + 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 + auto receive1 = builder + .receive () + .previous (epoch6->hash ()) + .source (send1->hash ()) + .sign (destination.prv, destination.pub) + .work (*pool.generate (epoch6->hash ())) + .build (); + ASSERT_EQ (nano::process_result::block_position, ledger.process (transaction, *receive1).code); + auto receive2 = builder + .state () + .account (destination.pub) + .previous (epoch6->hash ()) + .representative (destination.pub) + .balance (nano::Gxrb_ratio) + .link (send1->hash ()) + .sign (destination.prv, destination.pub) + .work (*pool.generate (epoch6->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *receive2).code); + ASSERT_EQ (nano::epoch::epoch_2, receive2->sideband ().details.epoch); + ASSERT_EQ (nano::epoch::epoch_1, receive2->sideband ().source_epoch); + ASSERT_EQ (0, ledger.balance (transaction, epoch6->hash ())); + ASSERT_EQ (nano::Gxrb_ratio, ledger.balance (transaction, receive2->hash ())); + ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, receive2->hash ())); ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::dev::genesis->account ())); ASSERT_EQ (nano::Gxrb_ratio, ledger.weight (destination.pub)); } @@ -2309,72 +3876,199 @@ TEST (ledger, epoch_blocks_receive_upgrade) store->initialize (transaction, ledger.cache, ledger.constants); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair destination; - nano::state_block send1 (nano::dev::genesis->account (), nano::dev::genesis->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::Gxrb_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::dev::genesis->account (), send1.hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::Gxrb_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::dev::genesis->account (), epoch1.hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::Gxrb_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 - nano::open_block open1 (send1.hash (), destination.pub, destination.pub, destination.prv, destination.pub, *pool.generate (destination.pub)); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, open1).code); - ASSERT_EQ (nano::epoch::epoch_0, open1.sideband ().details.epoch); - ASSERT_EQ (nano::epoch::epoch_0, open1.sideband ().source_epoch); - nano::receive_block receive1 (open1.hash (), send2.hash (), destination.prv, destination.pub, *pool.generate (open1.hash ())); - ASSERT_EQ (nano::process_result::unreceivable, ledger.process (transaction, receive1).code); - nano::state_block receive2 (destination.pub, open1.hash (), destination.pub, nano::Gxrb_ratio * 2, send2.hash (), destination.prv, destination.pub, *pool.generate (open1.hash ())); - 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); + nano::block_builder builder; + auto send1 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .link (destination.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); + auto epoch1 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (send1->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .link (ledger.epoch_link (nano::epoch::epoch_1)) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (send1->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *epoch1).code); + auto send2 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (epoch1->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 2) + .link (destination.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (epoch1->hash ())) + .build (); + 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 + auto open1 = builder + .open () + .source (send1->hash ()) + .representative (destination.pub) + .account (destination.pub) + .sign (destination.prv, destination.pub) + .work (*pool.generate (destination.pub)) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *open1).code); + ASSERT_EQ (nano::epoch::epoch_0, open1->sideband ().details.epoch); + ASSERT_EQ (nano::epoch::epoch_0, open1->sideband ().source_epoch); + auto receive1 = builder + .receive () + .previous (open1->hash ()) + .source (send2->hash ()) + .sign (destination.prv, destination.pub) + .work (*pool.generate (open1->hash ())) + .build (); + ASSERT_EQ (nano::process_result::unreceivable, ledger.process (transaction, *receive1).code); + auto receive2 = builder + .state () + .account (destination.pub) + .previous (open1->hash ()) + .representative (destination.pub) + .balance (nano::Gxrb_ratio * 2) + .link (send2->hash ()) + .sign (destination.prv, destination.pub) + .work (*pool.generate (open1->hash ())) + .build (); + 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); nano::account_info destination_info; ASSERT_FALSE (ledger.store.account.get (transaction, destination.pub, destination_info)); ASSERT_EQ (destination_info.epoch (), nano::epoch::epoch_1); - ASSERT_FALSE (ledger.rollback (transaction, receive2.hash ())); + ASSERT_FALSE (ledger.rollback (transaction, receive2->hash ())); ASSERT_FALSE (ledger.store.account.get (transaction, destination.pub, destination_info)); ASSERT_EQ (destination_info.epoch (), nano::epoch::epoch_0); nano::pending_info pending_send2; - ASSERT_FALSE (ledger.store.pending.get (transaction, nano::pending_key (destination.pub, send2.hash ()), 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_EQ (nano::Gxrb_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_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_EQ (destination_info.epoch (), nano::epoch::epoch_1); nano::keypair destination2; - nano::state_block send3 (destination.pub, receive2.hash (), destination.pub, nano::Gxrb_ratio, destination2.pub, destination.prv, destination.pub, *pool.generate (receive2.hash ())); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send3).code); - nano::open_block open2 (send3.hash (), destination2.pub, destination2.pub, destination2.prv, destination2.pub, *pool.generate (destination2.pub)); - ASSERT_EQ (nano::process_result::unreceivable, ledger.process (transaction, open2).code); + auto send3 = builder + .state () + .account (destination.pub) + .previous (receive2->hash ()) + .representative (destination.pub) + .balance (nano::Gxrb_ratio) + .link (destination2.pub) + .sign (destination.prv, destination.pub) + .work (*pool.generate (receive2->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send3).code); + auto open2 = builder + .open () + .source (send3->hash ()) + .representative (destination2.pub) + .account (destination2.pub) + .sign (destination2.prv, destination2.pub) + .work (*pool.generate (destination2.pub)) + .build (); + 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::dev::genesis->account (), send2.hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::Gxrb_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::dev::genesis->account (), epoch2.hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::Gxrb_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); + auto epoch2 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (send2->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 2) + .link (ledger.epoch_link (nano::epoch::epoch_2)) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (send2->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *epoch2).code); + auto send4 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (epoch2->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 3) + .link (destination3.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (epoch2->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send4).code); + auto open3 = builder + .open () + .source (send4->hash ()) + .representative (destination3.pub) + .account (destination3.pub) + .sign (destination3.prv, destination3.pub) + .work (*pool.generate (destination3.pub)) + .build (); + ASSERT_EQ (nano::process_result::unreceivable, ledger.process (transaction, *open3).code); // Send it to an epoch 1 account - nano::state_block send5 (nano::dev::genesis->account (), send4.hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::Gxrb_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); + auto send5 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (send4->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 4) + .link (destination.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (send4->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send5).code); 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::Gxrb_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); + auto receive3 = builder + .state () + .account (destination.pub) + .previous (send3->hash ()) + .representative (destination.pub) + .balance (nano::Gxrb_ratio * 2) + .link (send5->hash ()) + .sign (destination.prv, destination.pub) + .work (*pool.generate (send3->hash ())) + .build (); + 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_EQ (destination_info.epoch (), nano::epoch::epoch_2); // Upgrade an unopened account straight to epoch 2 nano::keypair destination4; - nano::state_block send6 (nano::dev::genesis->account (), send5.hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::Gxrb_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)); - 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 + auto send6 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (send5->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 5) + .link (destination4.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (send5->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send6).code); + auto epoch4 = builder + .state () + .account (destination4.pub) + .previous (0) + .representative (0) + .balance (0) + .link (ledger.epoch_link (nano::epoch::epoch_2)) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (destination4.pub)) + .build (); + 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); } @@ -2389,18 +4083,62 @@ TEST (ledger, epoch_blocks_fork) store->initialize (transaction, ledger.cache, ledger.constants); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair destination; - 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::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::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::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::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); + nano::block_builder builder; + auto send1 = builder + .send () + .previous (nano::dev::genesis->hash ()) + .destination (nano::account{}) + .balance (nano::dev::constants.genesis_amount) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); + auto epoch1 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount) + .link (ledger.epoch_link (nano::epoch::epoch_1)) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); + ASSERT_EQ (nano::process_result::fork, ledger.process (transaction, *epoch1).code); + auto epoch2 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount) + .link (ledger.epoch_link (nano::epoch::epoch_2)) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); + ASSERT_EQ (nano::process_result::fork, ledger.process (transaction, *epoch2).code); + auto epoch3 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (send1->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount) + .link (ledger.epoch_link (nano::epoch::epoch_1)) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (send1->hash ())) + .build (); + 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 + auto epoch4 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (send1->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount) + .link (ledger.epoch_link (nano::epoch::epoch_2)) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (send1->hash ())) + .build (); + ASSERT_EQ (nano::process_result::fork, ledger.process (transaction, *epoch2).code); } TEST (ledger, successor_epoch) @@ -2409,22 +4147,64 @@ TEST (ledger, successor_epoch) auto & node1 (*system.nodes[0]); nano::keypair key1; 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::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 ())); + nano::block_builder builder; + auto send1 = builder + .send () + .previous (nano::dev::genesis->hash ()) + .destination (key1.pub) + .balance (nano::dev::constants.genesis_amount - 1) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); + auto open = builder + .state () + .account (key1.pub) + .previous (0) + .representative (key1.pub) + .balance (1) + .link (send1->hash ()) + .sign (key1.prv, key1.pub) + .work (*pool.generate (key1.pub)) + .build (); + auto change = builder + .state () + .account (key1.pub) + .previous (open->hash ()) + .representative (key1.pub) + .balance (1) + .link (0) + .sign (key1.prv, key1.pub) + .work (*pool.generate (open->hash ())) + .build (); + auto open_hash = open->hash (); + auto send2 = builder + .send () + .previous (send1->hash ()) + .destination (reinterpret_cast (open_hash)) + .balance (nano::dev::constants.genesis_amount - 2) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (send1->hash ())) + .build (); + auto epoch_open = builder + .state () + .account (reinterpret_cast (open_hash)) + .previous (0) + .representative (0) + .balance (0) + .link (node1.ledger.epoch_link (nano::epoch::epoch_1)) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (open->hash ())) + .build (); 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); - ASSERT_EQ (nano::process_result::progress, node1.ledger.process (transaction, change).code); - ASSERT_EQ (nano::process_result::progress, node1.ledger.process (transaction, send2).code); - ASSERT_EQ (nano::process_result::progress, node1.ledger.process (transaction, epoch_open).code); - ASSERT_EQ (change, *node1.ledger.successor (transaction, change.qualified_root ())); - ASSERT_EQ (epoch_open, *node1.ledger.successor (transaction, epoch_open.qualified_root ())); - ASSERT_EQ (nano::epoch::epoch_1, epoch_open.sideband ().details.epoch); - ASSERT_EQ (nano::epoch::epoch_0, epoch_open.sideband ().source_epoch); // Not used for epoch state blocks + ASSERT_EQ (nano::process_result::progress, node1.ledger.process (transaction, *send1).code); + ASSERT_EQ (nano::process_result::progress, node1.ledger.process (transaction, *open).code); + ASSERT_EQ (nano::process_result::progress, node1.ledger.process (transaction, *change).code); + ASSERT_EQ (nano::process_result::progress, node1.ledger.process (transaction, *send2).code); + ASSERT_EQ (nano::process_result::progress, node1.ledger.process (transaction, *epoch_open).code); + ASSERT_EQ (*change, *node1.ledger.successor (transaction, change->qualified_root ())); + ASSERT_EQ (*epoch_open, *node1.ledger.successor (transaction, epoch_open->qualified_root ())); + ASSERT_EQ (nano::epoch::epoch_1, epoch_open->sideband ().details.epoch); + ASSERT_EQ (nano::epoch::epoch_0, epoch_open->sideband ().source_epoch); // Not used for epoch state blocks } TEST (ledger, epoch_open_pending) @@ -2571,53 +4351,134 @@ TEST (ledger, could_fit) 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 (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)); + nano::block_builder builder; + auto change1 = builder + .change () + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis->account ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); + auto change2 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount) + .link (0) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); + 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::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); - ASSERT_TRUE (ledger.could_fit (transaction, change1)); - ASSERT_TRUE (ledger.could_fit (transaction, change2)); - ASSERT_TRUE (ledger.could_fit (transaction, send1)); - ASSERT_TRUE (ledger.could_fit (transaction, send2)); + auto send1 = builder + .send () + .previous (change1->hash ()) + .destination (key1.pub) + .balance (nano::dev::constants.genesis_amount - 1) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (change1->hash ())) + .build (); + auto send2 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (change1->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - 1) + .link (key1.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (change1->hash ())) + .build (); + ASSERT_FALSE (ledger.could_fit (transaction, *send1)); + ASSERT_FALSE (ledger.could_fit (transaction, *send2)); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *change1).code); + ASSERT_TRUE (ledger.could_fit (transaction, *change1)); + ASSERT_TRUE (ledger.could_fit (transaction, *change2)); + ASSERT_TRUE (ledger.could_fit (transaction, *send1)); + ASSERT_TRUE (ledger.could_fit (transaction, *send2)); // Test legacy and state open - nano::open_block open1 (send2.hash (), nano::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); - ASSERT_TRUE (ledger.could_fit (transaction, send1)); - ASSERT_TRUE (ledger.could_fit (transaction, send2)); - ASSERT_TRUE (ledger.could_fit (transaction, open1)); - ASSERT_TRUE (ledger.could_fit (transaction, open2)); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, open1).code); - ASSERT_TRUE (ledger.could_fit (transaction, open1)); - ASSERT_TRUE (ledger.could_fit (transaction, open2)); + auto open1 = builder + .open () + .source (send2->hash ()) + .representative (nano::dev::genesis->account ()) + .account (key1.pub) + .sign (key1.prv, key1.pub) + .work (*pool.generate (key1.pub)) + .build (); + auto open2 = builder + .state () + .account (key1.pub) + .previous (0) + .representative (nano::dev::genesis->account ()) + .balance (1) + .link (send2->hash ()) + .sign (key1.prv, key1.pub) + .work (*pool.generate (key1.pub)) + .build (); + ASSERT_FALSE (ledger.could_fit (transaction, *open1)); + ASSERT_FALSE (ledger.could_fit (transaction, *open2)); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send2).code); + ASSERT_TRUE (ledger.could_fit (transaction, *send1)); + ASSERT_TRUE (ledger.could_fit (transaction, *send2)); + ASSERT_TRUE (ledger.could_fit (transaction, *open1)); + ASSERT_TRUE (ledger.could_fit (transaction, *open2)); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *open1).code); + ASSERT_TRUE (ledger.could_fit (transaction, *open1)); + ASSERT_TRUE (ledger.could_fit (transaction, *open2)); // Create another send to receive - nano::state_block send3 (nano::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 ())); + auto send3 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (send2->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - 2) + .link (key1.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (send2->hash ())) + .build (); // 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::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)); + auto receive1 = builder + .receive () + .previous (open1->hash ()) + .source (send3->hash ()) + .sign (key1.prv, key1.pub) + .work (*pool.generate (open1->hash ())) + .build (); + auto receive2 = builder + .state () + .account (key1.pub) + .previous (open1->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (2) + .link (send3->hash ()) + .sign (key1.prv, key1.pub) + .work (*pool.generate (open1->hash ())) + .build (); + 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::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)); - ASSERT_TRUE (ledger.could_fit (transaction, receive2)); - ASSERT_TRUE (ledger.could_fit (transaction, epoch1)); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, epoch1).code); - ASSERT_TRUE (ledger.could_fit (transaction, epoch1)); + auto epoch1 = builder + .state () + .account (key1.pub) + .previous (receive1->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (2) + .link (ledger.epoch_link (nano::epoch::epoch_1)) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (receive1->hash ())) + .build (); + ASSERT_FALSE (ledger.could_fit (transaction, *epoch1)); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *receive1).code); + ASSERT_TRUE (ledger.could_fit (transaction, *receive1)); + ASSERT_TRUE (ledger.could_fit (transaction, *receive2)); + ASSERT_TRUE (ledger.could_fit (transaction, *epoch1)); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *epoch1).code); + ASSERT_TRUE (ledger.could_fit (transaction, *epoch1)); } TEST (ledger, unchecked_epoch) @@ -2625,11 +4486,39 @@ TEST (ledger, unchecked_epoch) nano::system system (1); auto & node1 (*system.nodes[0]); nano::keypair destination; - auto send1 (std::make_shared (nano::dev::genesis->account (), nano::dev::genesis->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::Gxrb_ratio, destination.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0)); + nano::block_builder builder; + auto send1 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .link (destination.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (0) + .build_shared (); node1.work_generate_blocking (*send1); - auto open1 (std::make_shared (destination.pub, 0, destination.pub, nano::Gxrb_ratio, send1->hash (), destination.prv, destination.pub, 0)); + auto open1 = builder + .state () + .account (destination.pub) + .previous (0) + .representative (destination.pub) + .balance (nano::Gxrb_ratio) + .link (send1->hash ()) + .sign (destination.prv, destination.pub) + .work (0) + .build_shared (); node1.work_generate_blocking (*open1); - auto epoch1 (std::make_shared (destination.pub, open1->hash (), destination.pub, nano::Gxrb_ratio, node1.ledger.epoch_link (nano::epoch::epoch_1), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0)); + auto epoch1 = builder + .state () + .account (destination.pub) + .previous (open1->hash ()) + .representative (destination.pub) + .balance (nano::Gxrb_ratio) + .link (node1.ledger.epoch_link (nano::epoch::epoch_1)) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (0) + .build_shared (); node1.work_generate_blocking (*epoch1); node1.block_processor.add (epoch1); { @@ -2658,15 +4547,52 @@ TEST (ledger, unchecked_epoch_invalid) node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; auto & node1 (*system.add_node (node_config)); nano::keypair destination; - auto send1 (std::make_shared (nano::dev::genesis->account (), nano::dev::genesis->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::Gxrb_ratio, destination.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0)); + nano::block_builder builder; + auto send1 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .link (destination.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (0) + .build_shared (); node1.work_generate_blocking (*send1); - auto open1 (std::make_shared (destination.pub, 0, destination.pub, nano::Gxrb_ratio, send1->hash (), destination.prv, destination.pub, 0)); + auto open1 = builder + .state () + .account (destination.pub) + .previous (0) + .representative (destination.pub) + .balance (nano::Gxrb_ratio) + .link (send1->hash ()) + .sign (destination.prv, destination.pub) + .work (0) + .build_shared (); node1.work_generate_blocking (*open1); // Epoch block with account own signature - auto epoch1 (std::make_shared (destination.pub, open1->hash (), destination.pub, nano::Gxrb_ratio, node1.ledger.epoch_link (nano::epoch::epoch_1), destination.prv, destination.pub, 0)); + auto epoch1 = builder + .state () + .account (destination.pub) + .previous (open1->hash ()) + .representative (destination.pub) + .balance (nano::Gxrb_ratio) + .link (node1.ledger.epoch_link (nano::epoch::epoch_1)) + .sign (destination.prv, destination.pub) + .work (0) + .build_shared (); node1.work_generate_blocking (*epoch1); // Pseudo epoch block (send subtype, destination - epoch link) - auto epoch2 (std::make_shared (destination.pub, open1->hash (), destination.pub, nano::Gxrb_ratio - 1, node1.ledger.epoch_link (nano::epoch::epoch_1), destination.prv, destination.pub, 0)); + auto epoch2 = builder + .state () + .account (destination.pub) + .previous (open1->hash ()) + .representative (destination.pub) + .balance (nano::Gxrb_ratio - 1) + .link (node1.ledger.epoch_link (nano::epoch::epoch_1)) + .sign (destination.prv, destination.pub) + .work (0) + .build_shared (); node1.work_generate_blocking (*epoch2); node1.block_processor.add (epoch1); node1.block_processor.add (epoch2); @@ -2706,12 +4632,36 @@ TEST (ledger, unchecked_open) nano::system system (1); auto & node1 (*system.nodes[0]); nano::keypair destination; - auto send1 (std::make_shared (nano::dev::genesis->account (), nano::dev::genesis->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::Gxrb_ratio, destination.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0)); + nano::block_builder builder; + auto send1 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .link (destination.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (0) + .build_shared (); node1.work_generate_blocking (*send1); - auto open1 (std::make_shared (send1->hash (), destination.pub, destination.pub, destination.prv, destination.pub, 0)); + auto open1 = builder + .open () + .source (send1->hash ()) + .representative (destination.pub) + .account (destination.pub) + .sign (destination.prv, destination.pub) + .work (0) + .build_shared (); 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 = builder + .open () + .source (send1->hash ()) + .representative (nano::dev::genesis_key.pub) + .account (destination.pub) + .sign (destination.prv, destination.pub) + .work (0) + .build_shared (); node1.work_generate_blocking (*open2); open2->signature.bytes[0] ^= 1; node1.block_processor.add (open1); @@ -2734,13 +4684,45 @@ TEST (ledger, unchecked_receive) nano::system system{ 1 }; auto & node1 = *system.nodes[0]; nano::keypair destination{}; - auto send1 = std::make_shared (nano::dev::genesis->account (), nano::dev::genesis->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::Gxrb_ratio, destination.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0); + nano::block_builder builder; + auto send1 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .link (destination.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (0) + .build_shared (); node1.work_generate_blocking (*send1); - auto send2 = std::make_shared (nano::dev::genesis->account (), send1->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - 2 * nano::Gxrb_ratio, destination.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0); + auto send2 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (send1->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - 2 * nano::Gxrb_ratio) + .link (destination.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (0) + .build_shared (); node1.work_generate_blocking (*send2); - auto open1 = std::make_shared (send1->hash (), destination.pub, destination.pub, destination.prv, destination.pub, 0); + auto open1 = builder + .open () + .source (send1->hash ()) + .representative (destination.pub) + .account (destination.pub) + .sign (destination.prv, destination.pub) + .work (0) + .build_shared (); node1.work_generate_blocking (*open1); - auto receive1 = std::make_shared (open1->hash (), send2->hash (), destination.prv, destination.pub, 0); + auto receive1 = builder + .receive () + .previous (open1->hash ()) + .source (send2->hash ()) + .sign (destination.prv, destination.pub) + .work (0) + .build_shared (); node1.work_generate_blocking (*receive1); node1.block_processor.add (send1); node1.block_processor.add (receive1); @@ -2783,17 +4765,32 @@ TEST (ledger, confirmation_height_not_updated) nano::account_info 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::block_builder builder; + auto send1 = builder + .send () + .previous (account_info.head) + .destination (key.pub) + .balance (50) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (account_info.head)) + .build (); nano::confirmation_height_info 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 (nano::dev::genesis->hash (), confirmation_height_info.frontier); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); ASSERT_FALSE (store->confirmation_height.get (transaction, nano::dev::genesis->account (), confirmation_height_info)); ASSERT_EQ (1, confirmation_height_info.height); 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); + auto open1 = builder + .open () + .source (send1->hash ()) + .representative (nano::dev::genesis->account ()) + .account (key.pub) + .sign (key.prv, key.pub) + .work (*pool.generate (key.pub)) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *open1).code); 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); @@ -3201,46 +5198,74 @@ TEST (ledger, pruning_action) auto transaction (store->tx_begin_write ()); store->initialize (transaction, ledger.cache, ledger.constants); 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::Gxrb_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 ())); + nano::block_builder builder; + auto send1 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .link (nano::dev::genesis->account ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); + 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_NE (nullptr, send1_stored); - ASSERT_EQ (send1, *send1_stored); - 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::Gxrb_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_EQ (*send1, *send1_stored); + ASSERT_TRUE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send1->hash ()))); + auto send2 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (send1->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 2) + .link (nano::dev::genesis->account ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (send1->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send2).code); + ASSERT_TRUE (store->block.exists (transaction, send2->hash ())); // Pruning action - ASSERT_EQ (1, ledger.pruning_action (transaction, send1.hash (), 1)); + ASSERT_EQ (1, ledger.pruning_action (transaction, send1->hash (), 1)); 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 ())); + 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 ())); + ASSERT_TRUE (ledger.block_or_pruned_exists (transaction, send1->hash ())); ledger.pruning = true; - ASSERT_TRUE (store->pruned.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 ())); + ASSERT_TRUE (store->block.exists (transaction, send2->hash ())); // Receiving pruned block - nano::state_block receive1 (nano::dev::genesis->account (), send2.hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::Gxrb_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 ())); + auto receive1 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (send2->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .link (send1->hash ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (send2->hash ())) + .build (); + 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_NE (nullptr, receive1_stored); - ASSERT_EQ (receive1, *receive1_stored); - ASSERT_FALSE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send1.hash ()))); + ASSERT_EQ (*receive1, *receive1_stored); + 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_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_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); @@ -3259,15 +5284,34 @@ TEST (ledger, pruning_large_chain) nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; size_t send_receive_pairs (20); auto last_hash (nano::dev::genesis->hash ()); + nano::block_builder builder; for (auto i (0); i < send_receive_pairs; i++) { - nano::state_block send (nano::dev::genesis->account (), last_hash, nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::Gxrb_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::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 ())); - last_hash = receive.hash (); + auto send = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (last_hash) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .link (nano::dev::genesis->account ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (last_hash)) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send).code); + ASSERT_TRUE (store->block.exists (transaction, send->hash ())); + auto receive = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (send->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount) + .link (send->hash ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (send->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *receive).code); + 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)); @@ -3293,42 +5337,79 @@ TEST (ledger, pruning_source_rollback) auto transaction (store->tx_begin_write ()); store->initialize (transaction, ledger.cache, ledger.constants); 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::dev::genesis->account (), epoch1.hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::Gxrb_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::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::Gxrb_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 ())); + nano::block_builder builder; + auto epoch1 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount) + .link (ledger.epoch_link (nano::epoch::epoch_1)) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *epoch1).code); + auto send1 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (epoch1->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .link (nano::dev::genesis->account ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (epoch1->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); + ASSERT_TRUE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send1->hash ()))); + auto send2 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (send1->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 2) + .link (nano::dev::genesis->account ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (send1->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send2).code); + 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_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, nano::dev::genesis->hash ())); nano::pending_info info; - ASSERT_FALSE (store->pending.get (transaction, nano::pending_key (nano::dev::genesis->account (), send1.hash ()), info)); + 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::Gxrb_ratio, info.amount.number ()); ASSERT_EQ (nano::epoch::epoch_1, info.epoch); // Receiving pruned block - nano::state_block receive1 (nano::dev::genesis->account (), send2.hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::Gxrb_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::dev::genesis->account (), send1.hash ()))); + auto receive1 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (send2->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .link (send1->hash ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (send2->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *receive1).code); + 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 ())); + ASSERT_FALSE (ledger.rollback (transaction, receive1->hash ())); nano::pending_info info2; - ASSERT_FALSE (store->pending.get (transaction, nano::pending_key (nano::dev::genesis->account (), send1.hash ()), info2)); + 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::Gxrb_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::dev::genesis->account (), send1.hash ()))); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *receive1).code); + 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); } @@ -3344,69 +5425,104 @@ TEST (ledger, pruning_source_rollback_legacy) auto transaction (store->tx_begin_write ()); store->initialize (transaction, ledger.cache, ledger.constants); 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::Gxrb_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::dev::genesis->account (), send1.hash ()))); + nano::block_builder builder; + auto send1 = builder + .send () + .previous (nano::dev::genesis->hash ()) + .destination (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); + 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::dev::constants.genesis_amount - 2 * nano::Gxrb_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::dev::genesis->account (), nano::dev::constants.genesis_amount - 3 * nano::Gxrb_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::dev::genesis->account (), send3.hash ()))); + auto send2 = builder + .send () + .previous (send1->hash ()) + .destination (key1.pub) + .balance (nano::dev::constants.genesis_amount - 2 * nano::Gxrb_ratio) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (send1->hash ())) + .build (); + 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 ()))); + auto send3 = builder + .send () + .previous (send2->hash ()) + .destination (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - 3 * nano::Gxrb_ratio) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (send2->hash ())) + .build (); + 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::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_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, nano::dev::genesis->hash ())); nano::pending_info info1; - ASSERT_FALSE (store->pending.get (transaction, nano::pending_key (nano::dev::genesis->account (), send1.hash ()), info1)); + 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::Gxrb_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_FALSE (store->pending.get (transaction, nano::pending_key (key1.pub, send2->hash ()), info2)); ASSERT_EQ (nano::dev::genesis->account (), info2.source); ASSERT_EQ (nano::Gxrb_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 ())); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, receive1).code); - ASSERT_FALSE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send1.hash ()))); + auto receive1 = builder + .receive () + .previous (send3->hash ()) + .source (send1->hash ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (send3->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *receive1).code); + 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 ())); + ASSERT_FALSE (ledger.rollback (transaction, receive1->hash ())); nano::pending_info info3; - ASSERT_FALSE (store->pending.get (transaction, nano::pending_key (nano::dev::genesis->account (), send1.hash ()), info3)); + 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::Gxrb_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::dev::genesis->account (), send1.hash ()))); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *receive1).code); + 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::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 ()))); + auto open1 = builder + .open () + .source (send2->hash ()) + .representative (nano::dev::genesis->account ()) + .account (key1.pub) + .sign (key1.prv, key1.pub) + .work (*pool.generate (key1.pub)) + .build (); + 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_EQ (2, ledger.cache.pruned_count); ASSERT_EQ (6, ledger.cache.block_count); // Rollback open block - ASSERT_FALSE (ledger.rollback (transaction, open1.hash ())); + 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_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::Gxrb_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_EQ (nano::process_result::progress, ledger.process (transaction, *open1).code); + 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); } @@ -3422,19 +5538,38 @@ TEST (ledger, pruning_process_error) auto transaction (store->tx_begin_write ()); store->initialize (transaction, ledger.cache, ledger.constants); 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::Gxrb_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::block_builder builder; + auto send1 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .link (nano::dev::genesis->account ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); + 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_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 ())); // Attempt to process pruned block again - ASSERT_EQ (nano::process_result::old, ledger.process (transaction, send1).code); + ASSERT_EQ (nano::process_result::old, ledger.process (transaction, *send1).code); // Attept to process new block after pruned - nano::state_block send2 (nano::dev::genesis->account (), send1.hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::Gxrb_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); + auto send2 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (send1->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 2) + .link (nano::dev::genesis->account ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (send1->hash ())) + .build (); + 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); } @@ -3451,33 +5586,74 @@ TEST (ledger, pruning_legacy_blocks) auto transaction (store->tx_begin_write ()); store->initialize (transaction, ledger.cache, ledger.constants); 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::Gxrb_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::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 ())); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, change1).code); - nano::send_block send2 (change1.hash (), key1.pub, nano::dev::constants.genesis_amount - nano::Gxrb_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::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::dev::genesis->account (), 0, key1.prv, key1.pub, *pool.generate (open1.hash ())); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send3).code); + nano::block_builder builder; + auto send1 = builder + .send () + .previous (nano::dev::genesis->hash ()) + .destination (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); + ASSERT_TRUE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send1->hash ()))); + auto receive1 = builder + .receive () + .previous (send1->hash ()) + .source (send1->hash ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (send1->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *receive1).code); + auto change1 = builder + .change () + .previous (receive1->hash ()) + .representative (key1.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (receive1->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *change1).code); + auto send2 = builder + .send () + .previous (change1->hash ()) + .destination (key1.pub) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (change1->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send2).code); + auto open1 = builder + .open () + .source (send2->hash ()) + .representative (nano::dev::genesis->account ()) + .account (key1.pub) + .sign (key1.prv, key1.pub) + .work (*pool.generate (key1.pub)) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *open1).code); + auto send3 = builder + .send () + .previous (open1->hash ()) + .destination (nano::dev::genesis->account ()) + .balance (0) + .sign (key1.prv, key1.pub) + .work (*pool.generate (open1->hash ())) + .build (); + 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_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, 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_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); @@ -3495,34 +5671,53 @@ TEST (ledger, pruning_safe_functions) auto transaction (store->tx_begin_write ()); store->initialize (transaction, ledger.cache, ledger.constants); 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::Gxrb_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::dev::genesis->account (), send1.hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::Gxrb_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 ())); + nano::block_builder builder; + auto send1 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .link (nano::dev::genesis->account ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); + ASSERT_TRUE (store->block.exists (transaction, send1->hash ())); + auto send2 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (send1->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 2) + .link (nano::dev::genesis->account ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (send1->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send2).code); + 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 (ledger.block_or_pruned_exists (transaction, send1.hash ())); // true for pruned - ASSERT_TRUE (store->pruned.exists (transaction, send1.hash ())); + ASSERT_EQ (1, ledger.pruning_action (transaction, send1->hash (), 1)); + 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, nano::dev::genesis->hash ())); - ASSERT_TRUE (store->block.exists (transaction, send2.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_EQ (0, ledger.balance_safe (transaction, send1->hash (), error)); ASSERT_TRUE (error); error = false; - ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 2, ledger.balance_safe (transaction, send2.hash (), error)); + ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 2, ledger.balance_safe (transaction, send2->hash (), error)); ASSERT_FALSE (error); error = false; - ASSERT_EQ (0, ledger.amount_safe (transaction, send2.hash (), error)); + ASSERT_EQ (0, ledger.amount_safe (transaction, send2->hash (), error)); ASSERT_TRUE (error); error = false; - ASSERT_TRUE (ledger.account_safe (transaction, send1.hash (), error).is_zero ()); + ASSERT_TRUE (ledger.account_safe (transaction, send1->hash (), error).is_zero ()); ASSERT_TRUE (error); error = false; - ASSERT_EQ (nano::dev::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); } @@ -3537,18 +5732,37 @@ TEST (ledger, hash_root_random) auto transaction (store->tx_begin_write ()); store->initialize (transaction, ledger.cache, ledger.constants); 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::Gxrb_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::dev::genesis->account (), send1.hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::Gxrb_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 ())); + nano::block_builder builder; + auto send1 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .link (nano::dev::genesis->account ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); + ASSERT_TRUE (store->block.exists (transaction, send1->hash ())); + auto send2 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (send1->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 2) + .link (nano::dev::genesis->account ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (send1->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send2).code); + 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_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, nano::dev::genesis->hash ())); - ASSERT_TRUE (store->block.exists (transaction, send2.hash ())); + ASSERT_TRUE (store->block.exists (transaction, send2->hash ())); // Test random block including pruned bool done (false); auto iteration (0); @@ -3556,7 +5770,7 @@ TEST (ledger, hash_root_random) { ++iteration; auto root_hash (ledger.hash_root_random (transaction)); - done = (root_hash.first == send1.hash ()) && (root_hash.second.is_zero ()); + done = (root_hash.first == send1->hash ()) && (root_hash.second.is_zero ()); ASSERT_LE (iteration, 1000); } done = false; @@ -3564,7 +5778,7 @@ TEST (ledger, hash_root_random) { ++iteration; auto root_hash (ledger.hash_root_random (transaction)); - done = (root_hash.first == send2.hash ()) && (root_hash.second == send2.root ().as_block_hash ()); + done = (root_hash.first == send2->hash ()) && (root_hash.second == send2->root ().as_block_hash ()); ASSERT_LE (iteration, 1000); } } diff --git a/nano/core_test/message.cpp b/nano/core_test/message.cpp index 3a44370979..7541cd1acb 100644 --- a/nano/core_test/message.cpp +++ b/nano/core_test/message.cpp @@ -45,7 +45,16 @@ TEST (message, keepalive_deserialize) TEST (message, publish_serialization) { - nano::publish publish{ nano::dev::network_params.network, std::make_shared (0, 1, 2, nano::keypair ().prv, 4, 5) }; + nano::block_builder builder; + auto block = builder + .send () + .previous (0) + .destination (1) + .balance (2) + .sign (nano::keypair ().prv, 4) + .work (5) + .build_shared (); + nano::publish publish{ nano::dev::network_params.network, block }; ASSERT_EQ (nano::block_type::send, publish.header.block_type ()); std::vector bytes; { @@ -79,8 +88,18 @@ TEST (message, confirm_ack_hash_serialization) nano::keypair key1; nano::block_hash previous; nano::random_pool::generate_block (previous.bytes.data (), previous.bytes.size ()); - nano::state_block block (key1.pub, previous, key1.pub, 2, 4, key1.prv, key1.pub, 5); - hashes.push_back (block.hash ()); + nano::block_builder builder; + auto block = builder + .state () + .account (key1.pub) + .previous (previous) + .representative (key1.pub) + .balance (2) + .link (4) + .sign (key1.prv, key1.pub) + .work (5) + .build (); + hashes.push_back (block->hash ()); } nano::keypair representative1; auto vote (std::make_shared (representative1.pub, representative1.prv, 0, 0, hashes)); @@ -106,7 +125,15 @@ 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::block_builder builder; + auto block = builder + .send () + .previous (0) + .destination (key2.pub) + .balance (200) + .sign (nano::keypair ().prv, 2) + .work (3) + .build_shared (); nano::confirm_req req{ nano::dev::network_params.network, block }; std::vector bytes; { @@ -126,8 +153,16 @@ 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{ nano::dev::network_params.network, block.hash (), block.root () }; + nano::block_builder builder; + auto block = builder + .send () + .previous (1) + .destination (key2.pub) + .balance (200) + .sign (nano::keypair ().prv, 2) + .work (3) + .build (); + nano::confirm_req req{ nano::dev::network_params.network, block->hash (), block->root () }; std::vector bytes; { nano::vectorstream stream (bytes); @@ -149,17 +184,36 @@ TEST (message, confirm_req_hash_batch_serialization) nano::keypair key; nano::keypair representative; std::vector> roots_hashes; - nano::state_block open (key.pub, 0, representative.pub, 2, 4, key.prv, key.pub, 5); - roots_hashes.push_back (std::make_pair (open.hash (), open.root ())); + nano::block_builder builder; + auto open = builder + .state () + .account (key.pub) + .previous (0) + .representative (representative.pub) + .balance (2) + .link (4) + .sign (key.prv, key.pub) + .work (5) + .build (); + roots_hashes.push_back (std::make_pair (open->hash (), open->root ())); for (auto i (roots_hashes.size ()); i < 7; i++) { nano::keypair key1; nano::block_hash previous; nano::random_pool::generate_block (previous.bytes.data (), previous.bytes.size ()); - nano::state_block block (key1.pub, previous, representative.pub, 2, 4, key1.prv, key1.pub, 5); - roots_hashes.push_back (std::make_pair (block.hash (), block.root ())); + auto block = builder + .state () + .account (key1.pub) + .previous (previous) + .representative (representative.pub) + .balance (2) + .link (4) + .sign (key1.prv, key1.pub) + .work (5) + .build (); + roots_hashes.push_back (std::make_pair (block->hash (), block->root ())); } - roots_hashes.push_back (std::make_pair (open.hash (), open.root ())); + roots_hashes.push_back (std::make_pair (open->hash (), open->root ())); nano::confirm_req req{ nano::dev::network_params.network, roots_hashes }; std::vector bytes; { diff --git a/nano/core_test/message_parser.cpp b/nano/core_test/message_parser.cpp index 56afa3c0de..6088f5cc46 100644 --- a/nano/core_test/message_parser.cpp +++ b/nano/core_test/message_parser.cpp @@ -68,7 +68,15 @@ TEST (message_parser, exact_confirm_ack_size) 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::dev::network_params.network); - auto block (std::make_shared (1, 1, 2, nano::keypair ().prv, 4, *system.work.generate (nano::root (1)))); + nano::block_builder builder; + auto block = builder + .send () + .previous (1) + .destination (1) + .balance (2) + .sign (nano::keypair ().prv, 4) + .work (*system.work.generate (nano::root (1))) + .build_shared (); auto vote (std::make_shared (0, nano::keypair ().prv, 0, 0, std::vector{ block->hash () })); nano::confirm_ack message{ nano::dev::network_params.network, vote }; std::vector bytes; @@ -102,7 +110,15 @@ TEST (message_parser, exact_confirm_req_size) 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::dev::network_params.network); - auto block (std::make_shared (1, 1, 2, nano::keypair ().prv, 4, *system.work.generate (nano::root (1)))); + nano::block_builder builder; + auto block = builder + .send () + .previous (1) + .destination (1) + .balance (2) + .sign (nano::keypair ().prv, 4) + .work (*system.work.generate (nano::root (1))) + .build_shared (); nano::confirm_req message{ nano::dev::network_params.network, block }; std::vector bytes; { @@ -135,8 +151,16 @@ TEST (message_parser, exact_confirm_req_hash_size) 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::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{ nano::dev::network_params.network, block.hash (), block.root () }; + nano::block_builder builder; + auto block = builder + .send () + .previous (1) + .destination (1) + .balance (2) + .sign (nano::keypair ().prv, 4) + .work (*system.work.generate (nano::root (1))) + .build (); + nano::confirm_req message{ nano::dev::network_params.network, block->hash (), block->root () }; std::vector bytes; { nano::vectorstream stream (bytes); @@ -168,7 +192,15 @@ TEST (message_parser, exact_publish_size) 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::dev::network_params.network); - auto block (std::make_shared (1, 1, 2, nano::keypair ().prv, 4, *system.work.generate (nano::root (1)))); + nano::block_builder builder; + auto block = builder + .send () + .previous (1) + .destination (1) + .balance (2) + .sign (nano::keypair ().prv, 4) + .work (*system.work.generate (nano::root (1))) + .build_shared (); nano::publish message{ nano::dev::network_params.network, block }; std::vector bytes; { diff --git a/nano/core_test/network.cpp b/nano/core_test/network.cpp index fd6229df3a..bd3e17565c 100644 --- a/nano/core_test/network.cpp +++ b/nano/core_test/network.cpp @@ -220,7 +220,15 @@ TEST (network, send_discarded_publish) nano::system system (2); 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::block_builder builder; + auto block = builder + .send () + .previous (1) + .destination (1) + .balance (2) + .sign (nano::keypair ().prv, 4) + .work (*system.work.generate (nano::root (1))) + .build_shared (); { auto transaction (node1.store.tx_begin_read ()); node1.network.flood_block (block); @@ -238,7 +246,15 @@ TEST (network, send_invalid_publish) nano::system system (2); auto & node1 (*system.nodes[0]); auto & node2 (*system.nodes[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)))); + nano::block_builder builder; + auto block = builder + .send () + .previous (1) + .destination (1) + .balance (20) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::root (1))) + .build_shared (); { auto transaction (node1.store.tx_begin_read ()); node1.network.flood_block (block); @@ -270,9 +286,17 @@ TEST (network, send_valid_confirm_ack) 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_builder builder; + auto block2 = builder + .send () + .previous (latest1) + .destination (key2.pub) + .balance (50) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (latest1)) + .build (); nano::block_hash latest2 (node2.latest (nano::dev::genesis_key.pub)); - node1.process_active (std::make_shared (block2)); + node1.process_active (std::make_shared (*block2)); // Keep polling until latest block changes ASSERT_TIMELY (10s, node2.latest (nano::dev::genesis_key.pub) != latest2); // Make sure the balance has decreased after processing the block. @@ -301,10 +325,18 @@ TEST (network, send_valid_publish) 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)); - auto hash2 (block2.hash ()); + nano::block_builder builder; + auto block2 = builder + .send () + .previous (latest1) + .destination (key2.pub) + .balance (50) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (latest1)) + .build (); + auto hash2 (block2->hash ()); nano::block_hash latest2 (node2.latest (nano::dev::genesis_key.pub)); - node2.process_active (std::make_shared (block2)); + 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); @@ -319,7 +351,15 @@ 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::block_builder builder; + auto block = builder + .send () + .previous (0) + .destination (1) + .balance (20) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (0) + .build_shared (); 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) {}); @@ -334,7 +374,15 @@ 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::block_builder builder; + auto block1 = builder + .send () + .previous (0) + .destination (1) + .balance (20) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (0) + .build_shared (); 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) {}); @@ -342,20 +390,43 @@ TEST (network, send_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.work.epoch_2_receive, node1.network_params.work.epoch_1 - 1))); + auto block2 = builder + .send () + .previous (block1->hash ()) + .destination (1) + .balance (20) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (system.work_generate_limited (block1->hash (), node1.network_params.work.epoch_2_receive, node1.network_params.work.epoch_1 - 1)) + .build_shared (); 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.work.epoch_2))); + auto block3 = builder + .send () + .previous (block2->hash ()) + .destination (1) + .balance (20) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (block2->hash (), node1.network_params.work.epoch_2)) + .build_shared (); 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.work.epoch_2_receive, node1.network_params.work.epoch_1 - 1))); + auto block4 = builder + .state () + .account (nano::dev::genesis_key.pub) + .previous (block1->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (20) + .link (1) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (system.work_generate_limited (block1->hash (), node1.network_params.work.epoch_2_receive, node1.network_params.work.epoch_1 - 1)) + .build_shared (); 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); @@ -367,7 +438,15 @@ TEST (receivable_processor, confirm_insufficient_pos) { nano::system system (1); auto & node1 (*system.nodes[0]); - auto block1 (std::make_shared (nano::dev::genesis->hash (), 0, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0)); + nano::block_builder builder; + auto block1 = builder + .send () + .previous (nano::dev::genesis->hash ()) + .destination (0) + .balance (0) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (0) + .build_shared (); 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 ()); @@ -381,7 +460,15 @@ TEST (receivable_processor, confirm_sufficient_pos) { nano::system system (1); auto & node1 (*system.nodes[0]); - auto block1 (std::make_shared (nano::dev::genesis->hash (), 0, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0)); + nano::block_builder builder; + auto block1 = builder + .send () + .previous (nano::dev::genesis->hash ()) + .destination (0) + .balance (0) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (0) + .build_shared (); 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 ()); @@ -410,7 +497,15 @@ TEST (receivable_processor, send_with_receive) 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))); + nano::block_builder builder; + auto block1 = builder + .send () + .previous (latest1) + .destination (key2.pub) + .balance (amount - node1.config.receive_minimum.number ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (latest1)) + .build_shared (); 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)); diff --git a/nano/core_test/node.cpp b/nano/core_test/node.cpp index 71592d5b30..89b0e5c170 100644 --- a/nano/core_test/node.cpp +++ b/nano/core_test/node.cpp @@ -1140,10 +1140,20 @@ TEST (node, fork_no_vote_quorum) ASSERT_EQ (node1.config.receive_minimum.number (), node1.weight (key1)); ASSERT_EQ (node1.config.receive_minimum.number (), node2.weight (key1)); ASSERT_EQ (node1.config.receive_minimum.number (), node3.weight (key1)); - 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); + nano::block_builder builder; + auto send1 = builder + .state () + .account (nano::dev::genesis_key.pub) + .previous (block->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance ((nano::dev::constants.genesis_amount / 4) - (node1.config.receive_minimum.number () * 2)) + .link (key1) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (block->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, node1.process (*send1).code); + ASSERT_EQ (nano::process_result::progress, node2.process (*send1).code); + ASSERT_EQ (nano::process_result::progress, node3.process (*send1).code); auto key2 (system.wallet (2)->deterministic_insert ()); auto send2 = nano::send_block_builder () .previous (block->hash ()) @@ -1166,9 +1176,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) @@ -1508,16 +1518,24 @@ 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::block_builder builder; + auto send0 = builder + .send () + .previous (node0->latest (nano::dev::genesis_key.pub)) + .destination (key0.pub) + .balance (500) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (0) + .build (); { auto transaction (node0->store.tx_begin_write ()); - ASSERT_EQ (nano::process_result::progress, node0->ledger.process (transaction, send0).code); + ASSERT_EQ (nano::process_result::progress, node0->ledger.process (transaction, *send0).code); } ASSERT_FALSE (node1->bootstrap_initiator.in_progress ()); node1->bootstrap_initiator.bootstrap (node0->network.endpoint (), false); ASSERT_TRUE (node1->active.empty ()); system1.deadline_set (10s); - while (node1->block (send0.hash ()) == nullptr) + while (node1->block (send0->hash ()) == nullptr) { // Poll until the TCP connection is torn down and in_progress goes false system0.poll (); diff --git a/nano/core_test/prioritization.cpp b/nano/core_test/prioritization.cpp index b3879f52aa..abdf89d943 100644 --- a/nano/core_test/prioritization.cpp +++ b/nano/core_test/prioritization.cpp @@ -32,27 +32,77 @@ nano::keypair & key3 () } std::shared_ptr & blockzero () { - static std::shared_ptr result = std::make_shared (keyzero ().pub, 0, keyzero ().pub, 0, 0, keyzero ().prv, keyzero ().pub, 0); + nano::block_builder builder; + static auto result = builder + .state () + .account (keyzero ().pub) + .previous (0) + .representative (keyzero ().pub) + .balance (0) + .link (0) + .sign (keyzero ().prv, keyzero ().pub) + .work (0) + .build_shared (); return result; } std::shared_ptr & block0 () { - static std::shared_ptr result = std::make_shared (key0 ().pub, 0, key0 ().pub, nano::Gxrb_ratio, 0, key0 ().prv, key0 ().pub, 0); + nano::block_builder builder; + static auto result = builder + .state () + .account (key0 ().pub) + .previous (0) + .representative (key0 ().pub) + .balance (nano::Gxrb_ratio) + .link (0) + .sign (key0 ().prv, key0 ().pub) + .work (0) + .build_shared (); return result; } std::shared_ptr & block1 () { - static std::shared_ptr result = std::make_shared (key1 ().pub, 0, key1 ().pub, nano::Mxrb_ratio, 0, key1 ().prv, key1 ().pub, 0); + nano::block_builder builder; + static auto result = builder + .state () + .account (key1 ().pub) + .previous (0) + .representative (key1 ().pub) + .balance (nano::Mxrb_ratio) + .link (0) + .sign (key1 ().prv, key1 ().pub) + .work (0) + .build_shared (); return result; } std::shared_ptr & block2 () { - static std::shared_ptr result = std::make_shared (key2 ().pub, 0, key2 ().pub, nano::Gxrb_ratio, 0, key2 ().prv, key2 ().pub, 0); + nano::block_builder builder; + static auto result = builder + .state () + .account (key2 ().pub) + .previous (0) + .representative (key2 ().pub) + .balance (nano::Gxrb_ratio) + .link (0) + .sign (key2 ().prv, key2 ().pub) + .work (0) + .build_shared (); return result; } std::shared_ptr & block3 () { - static std::shared_ptr result = std::make_shared (key3 ().pub, 0, key3 ().pub, nano::Mxrb_ratio, 0, key3 ().prv, key3 ().pub, 0); + nano::block_builder builder; + static auto result = builder + .state () + .account (key3 ().pub) + .previous (0) + .representative (key3 ().pub) + .balance (nano::Mxrb_ratio) + .link (0) + .sign (key3 ().prv, key3 ().pub) + .work (0) + .build_shared (); return result; } diff --git a/nano/core_test/processor_service.cpp b/nano/core_test/processor_service.cpp index 6ad777b5c4..f6684bc2d1 100644 --- a/nano/core_test/processor_service.cpp +++ b/nano/core_test/processor_service.cpp @@ -20,9 +20,17 @@ TEST (processor_service, bad_send_signature) nano::account_info 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)); - send.signature.bytes[32] ^= 0x1; - ASSERT_EQ (nano::process_result::bad_signature, ledger.process (transaction, send).code); + nano::block_builder builder; + auto send = builder + .send () + .previous (info1.head) + .destination (nano::dev::genesis_key.pub) + .balance (50) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (info1.head)) + .build (); + send->signature.bytes[32] ^= 0x1; + ASSERT_EQ (nano::process_result::bad_signature, ledger.process (transaction, *send).code); } TEST (processor_service, bad_receive_signature) @@ -37,12 +45,26 @@ TEST (processor_service, bad_receive_signature) 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)); - nano::block_hash hash1 (send.hash ()); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send).code); + nano::block_builder builder; + auto send = builder + .send () + .previous (info1.head) + .destination (nano::dev::genesis_key.pub) + .balance (50) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (info1.head)) + .build (); + 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)); - receive.signature.bytes[32] ^= 0x1; - ASSERT_EQ (nano::process_result::bad_signature, ledger.process (transaction, receive).code); + auto receive = builder + .receive () + .previous (hash1) + .source (hash1) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (hash1)) + .build (); + 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 a8ca77e15a..94f83aa7d3 100644 --- a/nano/core_test/request_aggregator.cpp +++ b/nano/core_test/request_aggregator.cpp @@ -14,7 +14,17 @@ TEST (request_aggregator, one) 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); - 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::Gxrb_ratio, nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node.work_generate_blocking (nano::dev::genesis->hash ()))); + nano::block_builder builder; + auto send1 = builder + .state () + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_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 (); std::vector> request; request.emplace_back (send1->hash (), send1->root ()); auto channel (node.network.udp_channels.create (node.network.endpoint ())); @@ -190,7 +200,17 @@ TEST (request_aggregator, two_endpoints) node_config.peering_port = nano::get_available_port (); auto & node2 (*system.add_node (node_config, node_flags)); 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 ()))); + nano::block_builder builder; + auto send1 = builder + .state () + .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 (*node1.work_generate_blocking (nano::dev::genesis->hash ())) + .build_shared (); 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); @@ -274,7 +294,17 @@ TEST (request_aggregator, channel_lifetime) 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); - 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::Gxrb_ratio, nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node.work_generate_blocking (nano::dev::genesis->hash ()))); + nano::block_builder builder; + auto send1 = builder + .state () + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_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.ledger.process (node.store.tx_begin_write (), *send1).code); std::vector> request; request.emplace_back (send1->hash (), send1->root ()); @@ -294,7 +324,17 @@ TEST (request_aggregator, channel_update) 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); - 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::Gxrb_ratio, nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node.work_generate_blocking (nano::dev::genesis->hash ()))); + nano::block_builder builder; + auto send1 = builder + .state () + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_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.ledger.process (node.store.tx_begin_write (), *send1).code); std::vector> request; request.emplace_back (send1->hash (), send1->root ()); @@ -322,7 +362,17 @@ TEST (request_aggregator, channel_max_queue) node_config.max_queued_requests = 1; auto & node (*system.add_node (node_config)); 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::Gxrb_ratio, nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node.work_generate_blocking (nano::dev::genesis->hash ()))); + nano::block_builder builder; + auto send1 = builder + .state () + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_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.ledger.process (node.store.tx_begin_write (), *send1).code); std::vector> request; request.emplace_back (send1->hash (), send1->root ()); @@ -339,7 +389,17 @@ TEST (request_aggregator, unique) 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); - 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::Gxrb_ratio, nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node.work_generate_blocking (nano::dev::genesis->hash ()))); + nano::block_builder builder; + auto send1 = builder + .state () + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_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.ledger.process (node.store.tx_begin_write (), *send1).code); std::vector> request; request.emplace_back (send1->hash (), send1->root ()); diff --git a/nano/core_test/signing.cpp b/nano/core_test/signing.cpp index 3408d7613d..279c7f0a93 100644 --- a/nano/core_test/signing.cpp +++ b/nano/core_test/signing.cpp @@ -13,7 +13,17 @@ TEST (signature_checker, empty) TEST (signature_checker, bulk_single_thread) { nano::keypair key; - nano::state_block block (key.pub, 0, key.pub, 0, 0, key.prv, key.pub, 0); + nano::block_builder builder; + auto block = builder + .state () + .account (key.pub) + .previous (0) + .representative (key.pub) + .balance (0) + .link (0) + .sign (key.prv, key.pub) + .work (0) + .build (); nano::signature_checker checker (0); std::vector hashes; size_t size (1000); @@ -30,11 +40,11 @@ TEST (signature_checker, bulk_single_thread) verifications.resize (size); for (auto i (0); i < size; ++i) { - hashes.push_back (block.hash ()); + hashes.push_back (block->hash ()); messages.push_back (hashes.back ().bytes.data ()); lengths.push_back (sizeof (decltype (hashes)::value_type)); - pub_keys.push_back (block.hashables.account.bytes.data ()); - signatures.push_back (block.signature.bytes.data ()); + pub_keys.push_back (block->hashables.account.bytes.data ()); + signatures.push_back (block->signature.bytes.data ()); } nano::signature_check_set check = { size, messages.data (), lengths.data (), pub_keys.data (), signatures.data (), verifications.data () }; checker.verify (check); @@ -48,12 +58,31 @@ TEST (signature_checker, many_multi_threaded) auto signature_checker_work_func = [&checker] () { nano::keypair key; - nano::state_block block (key.pub, 0, key.pub, 0, 0, key.prv, key.pub, 0); - auto block_hash = block.hash (); - - nano::state_block invalid_block (key.pub, 0, key.pub, 0, 0, key.prv, key.pub, 0); - invalid_block.signature.bytes[31] ^= 0x1; - auto invalid_block_hash = block.hash (); + nano::block_builder builder; + auto block = builder + .state () + .account (key.pub) + .previous (0) + .representative (key.pub) + .balance (0) + .link (0) + .sign (key.prv, key.pub) + .work (0) + .build (); + auto block_hash = block->hash (); + + auto invalid_block = builder + .state () + .account (key.pub) + .previous (0) + .representative (key.pub) + .balance (0) + .link (0) + .sign (key.prv, key.pub) + .work (0) + .build (); + invalid_block->signature.bytes[31] ^= 0x1; + auto invalid_block_hash = block->hash (); constexpr auto num_check_sizes = 18; constexpr std::array check_sizes{ 2048, 256, 1024, 1, @@ -84,12 +113,12 @@ TEST (signature_checker, many_multi_threaded) std::fill (lengths[i].begin (), lengths[i].end (), sizeof (decltype (block_hash))); pub_keys[i].resize (check_size); - std::fill (pub_keys[i].begin (), pub_keys[i].end (), block.hashables.account.bytes.data ()); - pub_keys[i][last_signature_index] = invalid_block.hashables.account.bytes.data (); + std::fill (pub_keys[i].begin (), pub_keys[i].end (), block->hashables.account.bytes.data ()); + pub_keys[i][last_signature_index] = invalid_block->hashables.account.bytes.data (); signatures[i].resize (check_size); - std::fill (signatures[i].begin (), signatures[i].end (), block.signature.bytes.data ()); - signatures[i][last_signature_index] = invalid_block.signature.bytes.data (); + std::fill (signatures[i].begin (), signatures[i].end (), block->signature.bytes.data ()); + signatures[i][last_signature_index] = invalid_block->signature.bytes.data (); verifications[i].resize (check_size); @@ -125,11 +154,11 @@ TEST (signature_checker, one) verifications.resize (size); for (auto i (0); i < size; ++i) { - hashes.push_back (block.hash ()); + hashes.push_back (block->hash ()); messages.push_back (hashes.back ().bytes.data ()); lengths.push_back (sizeof (decltype (hashes)::value_type)); - pub_keys.push_back (block.hashables.account.bytes.data ()); - signatures.push_back (block.signature.bytes.data ()); + pub_keys.push_back (block->hashables.account.bytes.data ()); + signatures.push_back (block->signature.bytes.data ()); } nano::signature_check_set check = { size, messages.data (), lengths.data (), pub_keys.data (), signatures.data (), verifications.data () }; checker.verify (check); @@ -137,14 +166,24 @@ TEST (signature_checker, one) }; nano::keypair key; - nano::state_block block (key.pub, 0, key.pub, 0, 0, key.prv, key.pub, 0); + nano::block_builder builder; + auto block = builder + .state () + .account (key.pub) + .previous (0) + .representative (key.pub) + .balance (0) + .link (0) + .sign (key.prv, key.pub) + .work (0) + .build (); // Make signaure invalid and check result is incorrect - block.signature.bytes[31] ^= 0x1; + block->signature.bytes[31] ^= 0x1; verify_block (block, 0); // Make it valid and check for succcess - block.signature.bytes[31] ^= 0x1; + block->signature.bytes[31] ^= 0x1; verify_block (block, 1); } @@ -174,7 +213,17 @@ TEST (signature_checker, boundary_checks) std::vector signatures; signatures.reserve (max_size); nano::keypair key; - nano::state_block block (key.pub, 0, key.pub, 0, 0, key.prv, key.pub, 0); + nano::block_builder builder; + auto block = builder + .state () + .account (key.pub) + .previous (0) + .representative (key.pub) + .balance (0) + .link (0) + .sign (key.prv, key.pub) + .work (0) + .build (); size_t last_size = 0; for (auto size : sizes) @@ -186,11 +235,11 @@ TEST (signature_checker, boundary_checks) verifications.resize (size); for (auto i (0); i < extra_size; ++i) { - hashes.push_back (block.hash ()); + hashes.push_back (block->hash ()); messages.push_back (hashes.back ().bytes.data ()); lengths.push_back (sizeof (decltype (hashes)::value_type)); - pub_keys.push_back (block.hashables.account.bytes.data ()); - signatures.push_back (block.signature.bytes.data ()); + pub_keys.push_back (block->hashables.account.bytes.data ()); + signatures.push_back (block->signature.bytes.data ()); } nano::signature_check_set check = { size, messages.data (), lengths.data (), pub_keys.data (), signatures.data (), verifications.data () }; checker.verify (check); diff --git a/nano/core_test/system.cpp b/nano/core_test/system.cpp index 6fc89a9fa1..94e4262e40 100644 --- a/nano/core_test/system.cpp +++ b/nano/core_test/system.cpp @@ -52,7 +52,15 @@ TEST (system, DISABLED_generate_send_existing) // 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)); + nano::block_builder builder; + auto open_block = builder + .open () + .source (send_block->hash ()) + .representative (nano::dev::genesis->account ()) + .account (stake_preserver.pub) + .sign (stake_preserver.prv, stake_preserver.pub) + .work (0) + .build_shared (); node1.work_generate_blocking (*open_block); ASSERT_EQ (nano::process_result::progress, node1.ledger.process (transaction, *open_block).code); } @@ -97,7 +105,15 @@ TEST (system, DISABLED_generate_send_new) 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)); + nano::block_builder builder; + auto open_block = builder + .open () + .source (send_block->hash ()) + .representative (nano::dev::genesis->account ()) + .account (stake_preserver.pub) + .sign (stake_preserver.prv, stake_preserver.pub) + .work (0) + .build_shared (); node1.work_generate_blocking (*open_block); ASSERT_EQ (nano::process_result::progress, node1.ledger.process (transaction, *open_block).code); } diff --git a/nano/core_test/unchecked_map.cpp b/nano/core_test/unchecked_map.cpp index 867954beb5..e0875f4ddc 100644 --- a/nano/core_test/unchecked_map.cpp +++ b/nano/core_test/unchecked_map.cpp @@ -60,7 +60,15 @@ TEST (block_store, one_bootstrap) auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); nano::unchecked_map unchecked{ *store, false }; ASSERT_TRUE (!store->init_error ()); - auto block1 = std::make_shared (0, 1, 2, nano::keypair ().prv, 4, 5); + nano::block_builder builder; + auto block1 = builder + .send () + .previous (0) + .destination (1) + .balance (2) + .sign (nano::keypair ().prv, 4) + .work (5) + .build_shared (); unchecked.put (block1->hash (), nano::unchecked_info{ block1 }); auto check_block_is_listed = [&] (nano::transaction const & transaction_a, nano::block_hash const & block_hash_a) { return unchecked.get (transaction_a, block_hash_a).size () > 0; diff --git a/nano/core_test/wallet.cpp b/nano/core_test/wallet.cpp index 6af6ddd53c..c206e343e6 100644 --- a/nano/core_test/wallet.cpp +++ b/nano/core_test/wallet.cpp @@ -1112,8 +1112,16 @@ TEST (wallet, epoch_2_receive_unopened) 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.work.epoch_2)); - ASSERT_EQ (nano::process_result::progress, node.process (epoch2_unopened).code); + auto epoch2_unopened = builder + .account (key.pub) + .previous (0) + .representative (0) + .balance (0) + .link (node.network_params.ledger.epochs.link (nano::epoch::epoch_2)) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (key.pub, node.network_params.work.epoch_2)) + .build (); + ASSERT_EQ (nano::process_result::progress, node.process (*epoch2_unopened).code); wallet.insert_adhoc (key.prv, false); diff --git a/nano/core_test/wallets.cpp b/nano/core_test/wallets.cpp index 819c2a1743..e13cf12ab3 100644 --- a/nano/core_test/wallets.cpp +++ b/nano/core_test/wallets.cpp @@ -97,15 +97,52 @@ TEST (wallets, vote_minimum) auto & node1 (*system.nodes[0]); nano::keypair key1; nano::keypair key2; - 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); + nano::block_builder builder; + auto send1 = builder + .state () + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (std::numeric_limits::max () - node1.config.vote_minimum.number ()) + .link (key1.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, node1.process (*send1).code); + auto open1 = builder + .state () + .account (key1.pub) + .previous (0) + .representative (key1.pub) + .balance (node1.config.vote_minimum.number ()) + .link (send1->hash ()) + .sign (key1.prv, key1.pub) + .work (*system.work.generate (key1.pub)) + .build (); + 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 ())); - 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); + auto send2 = builder + .state () + .account (nano::dev::genesis_key.pub) + .previous (send1->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (std::numeric_limits::max () - 2 * node1.config.vote_minimum.number () + 1) + .link (key2.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (send1->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, node1.process (*send2).code); + auto open2 = builder + .state () + .account (key2.pub) + .previous (0) + .representative (key2.pub) + .balance (node1.config.vote_minimum.number () - 1) + .link (send2->hash ()) + .sign (key2.prv, key2.pub) + .work (*system.work.generate (key2.pub)) + .build (); + ASSERT_EQ (nano::process_result::progress, node1.process (*open2).code); auto wallet (node1.wallets.items.begin ()->second); nano::unique_lock representatives_lk (wallet->representatives_mutex); ASSERT_EQ (0, wallet->representatives.size ()); diff --git a/nano/core_test/websocket.cpp b/nano/core_test/websocket.cpp index a266ef4f0a..df2cf3cf9b 100644 --- a/nano/core_test/websocket.cpp +++ b/nano/core_test/websocket.cpp @@ -89,7 +89,15 @@ TEST (websocket, confirmation) { 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))); + nano::block_builder builder; + auto send = builder + .send () + .previous (previous) + .destination (key.pub) + .balance (balance) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (previous)) + .build_shared (); node1->process_active (send); } @@ -180,7 +188,15 @@ TEST (websocket, stopped_election) // Create election, then erase it, causing a websocket message to be emitted nano::keypair key1; - 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::block_builder builder; + auto send1 = builder + .send () + .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 (nano::dev::genesis->hash ())) + .build_shared (); nano::publish publish1{ nano::dev::network_params.network, send1 }; auto channel1 (node1->network.udp_channels.create (node1->network.endpoint ())); node1->network.inbound (publish1, channel1); @@ -327,7 +343,15 @@ 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))); + nano::block_builder builder; + auto send = builder + .send () + .previous (previous) + .destination (key.pub) + .balance (balance) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (previous)) + .build_shared (); node1->process_active (send); previous = send->hash (); } diff --git a/nano/core_test/work_pool.cpp b/nano/core_test/work_pool.cpp index 722acd6665..99fafac728 100644 --- a/nano/core_test/work_pool.cpp +++ b/nano/core_test/work_pool.cpp @@ -16,9 +16,16 @@ TEST (work, one) { 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::dev::network_params.work.threshold_base (block.work_version ()), nano::dev::network_params.work.difficulty (block)); + nano::block_builder builder; + auto block = builder + .change () + .previous (1) + .representative (1) + .sign (nano::keypair ().prv, 3) + .work (4) + .build (); + block->block_work_set (*pool.generate (block->root ())); + ASSERT_LT (nano::dev::network_params.work.threshold_base (block->work_version ()), nano::dev::network_params.work.difficulty (*block)); } TEST (work, disabled) @@ -31,10 +38,18 @@ TEST (work, disabled) TEST (work, validate) { 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 (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::dev::network_params.work.threshold_base (send_block.work_version ()), nano::dev::network_params.work.difficulty (send_block)); + nano::block_builder builder; + auto send_block = builder + .send () + .previous (1) + .destination (1) + .balance (2) + .sign (nano::keypair ().prv, 4) + .work (6) + .build (); + 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::dev::network_params.work.threshold_base (send_block->work_version ()), nano::dev::network_params.work.difficulty (*send_block)); } TEST (work, cancel) diff --git a/nano/nano_node/entry.cpp b/nano/nano_node/entry.cpp index 3bbc0a0452..0978224c5a 100644 --- a/nano/nano_node/entry.cpp +++ b/nano/nano_node/entry.cpp @@ -889,12 +889,20 @@ int main (int argc, char * const * argv) while (true) { nano::keypair key; + nano::block_builder builder; nano::block_hash latest (0); auto begin1 (std::chrono::high_resolution_clock::now ()); for (uint64_t balance (0); balance < 1000; ++balance) { - nano::send_block send (latest, key.pub, balance, key.prv, key.pub, 0); - latest = send.hash (); + auto send = builder + .send () + .previous (latest) + .destination (key.pub) + .balance (balance) + .sign (key.prv, key.pub) + .work (0) + .build (); + latest = send->hash (); } auto end1 (std::chrono::high_resolution_clock::now ()); std::cerr << boost::str (boost::format ("%|1$ 12d|\n") % std::chrono::duration_cast (end1 - begin1).count ()); diff --git a/nano/rpc_test/rpc.cpp b/nano/rpc_test/rpc.cpp index 01b7917ffb..3b3a31221b 100644 --- a/nano/rpc_test/rpc.cpp +++ b/nano/rpc_test/rpc.cpp @@ -325,8 +325,15 @@ TEST (rpc, account_weight) 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); + nano::block_builder builder; + auto block = builder + .change () + .previous (latest) + .representative (key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node1->work_generate_blocking (latest)) + .build (); + ASSERT_EQ (nano::process_result::progress, node1->process (*block).code); auto const rpc_ctx = add_rpc (system, node1); boost::property_tree::ptree request; request.put ("action", "account_weight"); @@ -1100,19 +1107,47 @@ TEST (rpc, history) 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 ())); ASSERT_NE (nullptr, receive); - nano::state_block usend (nano::dev::genesis->account (), node0->latest (nano::dev::genesis->account ()), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::Gxrb_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 ())); + nano::block_builder builder; + auto usend = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (node0->latest (nano::dev::genesis->account ())) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .link (nano::dev::genesis->account ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node0->work_generate_blocking (node0->latest (nano::dev::genesis->account ()))) + .build (); + auto ureceive = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (usend->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount) + .link (usend->hash ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node0->work_generate_blocking (usend->hash ())) + .build (); + auto uchange = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (ureceive->hash ()) + .representative (nano::keypair ().pub) + .balance (nano::dev::constants.genesis_amount) + .link (0) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node0->work_generate_blocking (ureceive->hash ())) + .build (); { 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); + 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); } auto const rpc_ctx = add_rpc (system, node0); boost::property_tree::ptree request; request.put ("action", "history"); - request.put ("hash", uchange.hash ().to_string ()); + request.put ("hash", uchange->hash ().to_string ()); request.put ("count", 100); auto response (wait_response (system, rpc_ctx, request)); std::vector> history_l; @@ -1123,12 +1158,12 @@ 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 (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::Gxrb_ratio.convert_to (), std::get<2> (history_l[0])); ASSERT_EQ (5, history_l.size ()); ASSERT_EQ ("send", std::get<0> (history_l[1])); - ASSERT_EQ (usend.hash ().to_string (), std::get<3> (history_l[1])); + ASSERT_EQ (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::Gxrb_ratio.convert_to (), std::get<2> (history_l[1])); ASSERT_EQ ("receive", std::get<0> (history_l[2])); @@ -1156,14 +1191,42 @@ TEST (rpc, account_history) 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 ())); ASSERT_NE (nullptr, receive); - nano::state_block usend (nano::dev::genesis->account (), node0->latest (nano::dev::genesis->account ()), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::Gxrb_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 ())); + nano::block_builder builder; + auto usend = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (node0->latest (nano::dev::genesis->account ())) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .link (nano::dev::genesis->account ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node0->work_generate_blocking (node0->latest (nano::dev::genesis->account ()))) + .build (); + auto ureceive = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (usend->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount) + .link (usend->hash ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node0->work_generate_blocking (usend->hash ())) + .build (); + auto uchange = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (ureceive->hash ()) + .representative (nano::keypair ().pub) + .balance (nano::dev::constants.genesis_amount) + .link (0) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node0->work_generate_blocking (ureceive->hash ())) + .build (); { 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); + 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); } auto const rpc_ctx = add_rpc (system, node0); { @@ -1181,13 +1244,13 @@ TEST (rpc, account_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 (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::Gxrb_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 (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::Gxrb_ratio.convert_to (), std::get<2> (history_l[1])); ASSERT_EQ ("5", std::get<4> (history_l[1])); @@ -1294,15 +1357,62 @@ 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); - 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 ()))); + nano::block_builder builder; + auto change = builder + .change () + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node0->work.generate (nano::dev::genesis->hash ())) + .build_shared (); node0->process_active (change); - 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 ()))); + auto send = builder + .send () + .previous (change->hash ()) + .destination (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - node0->config.receive_minimum.number ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node0->work.generate (change->hash ())) + .build_shared (); 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 = builder + .receive () + .previous (send->hash ()) + .source (send->hash ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node0->work.generate (send->hash ())) + .build_shared (); node0->process_active (receive); - auto usend (std::make_shared (nano::dev::genesis->account (), receive->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::Gxrb_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 ()))); + auto usend = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (receive->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .link (nano::dev::genesis->account ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node0->work_generate_blocking (receive->hash ())) + .build_shared (); + auto ureceive = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (usend->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount) + .link (usend->hash ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node0->work_generate_blocking (usend->hash ())) + .build_shared (); + auto uchange = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (ureceive->hash ()) + .representative (nano::keypair ().pub) + .balance (nano::dev::constants.genesis_amount) + .link (0) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node0->work_generate_blocking (ureceive->hash ())) + .build_shared (); node0->process_active (usend); node0->process_active (ureceive); node0->process_active (uchange); @@ -1433,17 +1543,25 @@ TEST (rpc, process_block) auto const 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::block_builder builder; + auto send = builder + .send () + .previous (latest) + .destination (key.pub) + .balance (100) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node1->work_generate_blocking (latest)) + .build (); boost::property_tree::ptree request; request.put ("action", "process"); std::string json; - send.serialize_json (json); + send->serialize_json (json); request.put ("block", json); { auto response (wait_response (system, rpc_ctx, request)); - ASSERT_TIMELY (10s, node1->latest (nano::dev::genesis_key.pub) == send.hash ()); + 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); + ASSERT_EQ (send->hash ().to_string (), send_hash); } request.put ("json_block", true); { @@ -1460,11 +1578,19 @@ TEST (rpc, process_json_block) auto const 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::block_builder builder; + auto send = builder + .send () + .previous (latest) + .destination (key.pub) + .balance (100) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node1->work_generate_blocking (latest)) + .build (); boost::property_tree::ptree request; request.put ("action", "process"); boost::property_tree::ptree block_node; - send.serialize_json (block_node); + send->serialize_json (block_node); request.add_child ("block", block_node); { auto response (wait_response (system, rpc_ctx, request)); @@ -1474,9 +1600,9 @@ TEST (rpc, process_json_block) request.put ("json_block", true); { auto response (wait_response (system, rpc_ctx, request)); - ASSERT_TIMELY (10s, node1->latest (nano::dev::genesis_key.pub) == send.hash ()); + 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); + ASSERT_EQ (send->hash ().to_string (), send_hash); } } @@ -1487,12 +1613,20 @@ TEST (rpc, process_block_async) auto const 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::block_builder builder; + auto send = builder + .send () + .previous (latest) + .destination (key.pub) + .balance (100) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node1->work_generate_blocking (latest)) + .build (); boost::property_tree::ptree request; request.put ("action", "process"); request.put ("async", "true"); std::string json; - send.serialize_json (json); + send->serialize_json (json); request.put ("block", json); request.put ("json_block", true); { @@ -1507,7 +1641,16 @@ TEST (rpc, process_block_async) 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::dev::constants.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 = builder + .state () + .account (nano::dev::genesis_key.pub) + .previous (latest) + .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 (*system.work.generate (latest)) + .build_shared (); std::string json1; state_send->serialize_json (json1); request.put ("block", json1); @@ -1525,12 +1668,20 @@ TEST (rpc, process_block_no_work) auto const 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)); - send.block_work_set (0); + nano::block_builder builder; + auto send = builder + .send () + .previous (latest) + .destination (key.pub) + .balance (100) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node1->work_generate_blocking (latest)) + .build (); + send->block_work_set (0); boost::property_tree::ptree request; request.put ("action", "process"); std::string json; - send.serialize_json (json); + send->serialize_json (json); request.put ("block", json); auto response (wait_response (system, rpc_ctx, request)); ASSERT_FALSE (response.get ("error", "").empty ()); @@ -1545,14 +1696,22 @@ TEST (rpc, process_republish) auto const 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::block_builder builder; + auto send = builder + .send () + .previous (latest) + .destination (key.pub) + .balance (100) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node3->work_generate_blocking (latest)) + .build (); boost::property_tree::ptree request; request.put ("action", "process"); std::string json; - send.serialize_json (json); + send->serialize_json (json); request.put ("block", json); auto response (wait_response (system, rpc_ctx, request)); - ASSERT_TIMELY (10s, node2.latest (nano::dev::genesis_key.pub) == send.hash ()); + ASSERT_TIMELY (10s, node2.latest (nano::dev::genesis_key.pub) == send->hash ()); } TEST (rpc, process_subtype_send) @@ -1563,11 +1722,21 @@ TEST (rpc, process_subtype_send) auto const rpc_ctx = add_rpc (system, node1); nano::keypair key; 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::Gxrb_ratio, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node1->work_generate_blocking (latest)); + nano::block_builder builder; + auto send = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (latest) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .link (key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node1->work_generate_blocking (latest)) + .build (); boost::property_tree::ptree request; request.put ("action", "process"); std::string json; - send.serialize_json (json); + send->serialize_json (json); request.put ("block", json); request.put ("subtype", "receive"); auto response (wait_response (system, rpc_ctx, request)); @@ -1578,8 +1747,8 @@ TEST (rpc, process_subtype_send) ASSERT_EQ (response2.get ("error"), ec.message ()); request.put ("subtype", "send"); auto response3 (wait_response (system, rpc_ctx, request)); - ASSERT_EQ (send.hash ().to_string (), response3.get ("hash")); - ASSERT_TIMELY (10s, system.nodes[1]->latest (nano::dev::genesis_key.pub) == send.hash ()); + 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) @@ -1589,16 +1758,35 @@ TEST (rpc, process_subtype_open) auto & node2 = *system.add_node (); nano::keypair key; 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::Gxrb_ratio, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node1->work_generate_blocking (latest)); + nano::block_builder builder; + auto send = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (latest) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .link (key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node1->work_generate_blocking (latest)) + .build_shared (); ASSERT_EQ (nano::process_result::progress, node1->process (*send).code); ASSERT_EQ (nano::process_result::progress, node2.process (*send).code); auto const rpc_ctx = add_rpc (system, node1); node1->scheduler.manual (send); - nano::state_block open (key.pub, 0, key.pub, nano::Gxrb_ratio, send->hash (), key.prv, key.pub, *node1->work_generate_blocking (key.pub)); + auto open = builder + .state () + .account (key.pub) + .previous (0) + .representative (key.pub) + .balance (nano::Gxrb_ratio) + .link (send->hash ()) + .sign (key.prv, key.pub) + .work (*node1->work_generate_blocking (key.pub)) + .build (); boost::property_tree::ptree request; request.put ("action", "process"); std::string json; - open.serialize_json (json); + open->serialize_json (json); request.put ("block", json); request.put ("subtype", "send"); auto response (wait_response (system, rpc_ctx, request)); @@ -1609,8 +1797,8 @@ TEST (rpc, process_subtype_open) ASSERT_EQ (response2.get ("error"), ec.message ()); request.put ("subtype", "open"); auto response3 (wait_response (system, rpc_ctx, request)); - ASSERT_EQ (open.hash ().to_string (), response3.get ("hash")); - ASSERT_TIMELY (10s, node2.latest (key.pub) == open.hash ()); + ASSERT_EQ (open->hash ().to_string (), response3.get ("hash")); + ASSERT_TIMELY (10s, node2.latest (key.pub) == open->hash ()); } TEST (rpc, process_subtype_receive) @@ -1619,16 +1807,35 @@ TEST (rpc, process_subtype_receive) 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::dev::genesis->account (), latest, nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::Gxrb_ratio, nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node1->work_generate_blocking (latest)); + nano::block_builder builder; + auto send = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (latest) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .link (nano::dev::genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node1->work_generate_blocking (latest)) + .build_shared (); ASSERT_EQ (nano::process_result::progress, node1->process (*send).code); ASSERT_EQ (nano::process_result::progress, node2.process (*send).code); auto const 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 ())); + auto receive = builder + .state () + .account (nano::dev::genesis_key.pub) + .previous (send->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount) + .link (send->hash ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node1->work_generate_blocking (send->hash ())) + .build (); boost::property_tree::ptree request; request.put ("action", "process"); std::string json; - receive.serialize_json (json); + receive->serialize_json (json); request.put ("block", json); request.put ("subtype", "send"); auto response (wait_response (system, rpc_ctx, request)); @@ -1640,8 +1847,8 @@ TEST (rpc, process_subtype_receive) ASSERT_EQ (response2.get ("error"), ec.message ()); request.put ("subtype", "receive"); auto response3 (wait_response (system, rpc_ctx, request)); - ASSERT_EQ (receive.hash ().to_string (), response3.get ("hash")); - ASSERT_TIMELY (10s, node2.latest (nano::dev::genesis_key.pub) == receive.hash ()); + 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) @@ -1653,13 +1860,23 @@ TEST (rpc, process_ledger_insufficient_work) 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::Gxrb_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); + nano::block_builder builder; + auto send = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (latest) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .link (nano::dev::genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (system.work_generate_limited (latest, min_difficulty, max_difficulty)) + .build (); + 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); + send->serialize_json (json); request.put ("block", json); request.put ("subtype", "send"); auto response (wait_response (system, rpc_ctx, request)); @@ -2049,10 +2266,18 @@ TEST (rpc, search_receivable) 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::dev::constants.genesis_amount - node->config.receive_minimum.number (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node->work_generate_blocking (latest)); + nano::block_builder builder; + auto block = builder + .send () + .previous (latest) + .destination (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - node->config.receive_minimum.number ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node->work_generate_blocking (latest)) + .build (); { auto transaction (node->store.tx_begin_write ()); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, block).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *block).code); } auto const rpc_ctx = add_rpc (system, node); boost::property_tree::ptree request; @@ -2226,15 +2451,25 @@ TEST (rpc, work_generate_block_high) auto node = add_ipc_enabled_node (system); auto const rpc_ctx = add_rpc (system, node); nano::keypair key; - nano::state_block block (key.pub, 0, nano::dev::genesis_key.pub, nano::Gxrb_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::dev::network_params.work.difficulty (nano::work_version::work_1, hash, block.block_work ())); + nano::block_builder builder; + auto block = builder + .state () + .account (key.pub) + .previous (0) + .representative (nano::dev::genesis_key.pub) + .balance (nano::Gxrb_ratio) + .link (123) + .sign (key.prv, key.pub) + .work (*node->work_generate_blocking (key.pub)) + .build (); + nano::block_hash hash (block->root ().as_block_hash ()); + 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 ()); request.put ("json_block", "true"); boost::property_tree::ptree json; - block.serialize_json (json); + block->serialize_json (json); request.add_child ("block", json); { auto response (wait_response (system, rpc_ctx, request)); @@ -2249,18 +2484,28 @@ TEST (rpc, work_generate_block_low) auto node = add_ipc_enabled_node (system); auto const rpc_ctx = add_rpc (system, node); nano::keypair key; - nano::state_block block (key.pub, 0, nano::dev::genesis_key.pub, nano::Gxrb_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 (nano::dev::network_params.work.difficulty (block)); + nano::block_builder builder; + auto block = builder + .state () + .account (key.pub) + .previous (0) + .representative (nano::dev::genesis_key.pub) + .balance (nano::Gxrb_ratio) + .link (123) + .sign (key.prv, key.pub) + .work (0) + .build (); + 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 (nano::dev::network_params.work.difficulty (*block)); boost::property_tree::ptree request; request.put ("action", "work_generate"); request.put ("hash", hash.to_string ()); request.put ("difficulty", nano::to_string_hex (block_difficulty + 1)); request.put ("json_block", "false"); std::string json; - block.serialize_json (json); + block->serialize_json (json); request.put ("block", json); { auto response (wait_response (system, rpc_ctx, request, 10s)); @@ -2268,7 +2513,7 @@ TEST (rpc, work_generate_block_low) ASSERT_TRUE (work_text.is_initialized ()); uint64_t work; ASSERT_FALSE (nano::from_string_hex (*work_text, work)); - ASSERT_NE (block.block_work (), work); + ASSERT_NE (block->block_work (), work); 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; @@ -2284,14 +2529,24 @@ TEST (rpc, work_generate_block_root_mismatch) auto node = add_ipc_enabled_node (system); auto const rpc_ctx = add_rpc (system, node); nano::keypair key; - nano::state_block block (key.pub, 0, nano::dev::genesis_key.pub, nano::Gxrb_ratio, 123, key.prv, key.pub, *node->work_generate_blocking (key.pub)); + nano::block_builder builder; + auto block = builder + .state () + .account (key.pub) + .previous (0) + .representative (nano::dev::genesis_key.pub) + .balance (nano::Gxrb_ratio) + .link (123) + .sign (key.prv, key.pub) + .work (*node->work_generate_blocking (key.pub)) + .build (); nano::block_hash hash (1); boost::property_tree::ptree request; request.put ("action", "work_generate"); request.put ("hash", hash.to_string ()); request.put ("json_block", "false"); std::string json; - block.serialize_json (json); + block->serialize_json (json); request.put ("block", json); { auto response (wait_response (system, rpc_ctx, request)); @@ -2312,17 +2567,27 @@ TEST (rpc, work_generate_block_ledger_epoch_2) 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::Gxrb_ratio)); ASSERT_NE (nullptr, send_block); - nano::state_block block (key.pub, 0, nano::dev::genesis_key.pub, nano::Gxrb_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 ()); + nano::block_builder builder; + auto block = builder + .state () + .account (key.pub) + .previous (0) + .representative (nano::dev::genesis_key.pub) + .balance (nano::Gxrb_ratio) + .link (send_block->hash ()) + .sign (key.prv, key.pub) + .work (0) + .build (); + 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 const rpc_ctx = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "work_generate"); request.put ("hash", hash.to_string ()); request.put ("json_block", "false"); std::string json; - block.serialize_json (json); + block->serialize_json (json); request.put ("block", json); bool finished (false); auto iteration (0); @@ -2509,9 +2774,23 @@ TEST (rpc, block_count_pruning) 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::dev::constants.genesis_amount - nano::Gxrb_ratio, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node1->work_generate_blocking (latest))); + nano::block_builder builder; + auto send1 = builder + .send () + .previous (latest) + .destination (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node1->work_generate_blocking (latest)) + .build_shared (); 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 ()))); + auto receive1 = builder + .receive () + .previous (send1->hash ()) + .source (send1->hash ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node1->work_generate_blocking (send1->hash ())) + .build_shared (); node1->process_active (receive1); node1->block_processor.flush (); system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); @@ -2767,10 +3046,18 @@ TEST (rpc, bootstrap) nano::system system1 (1); 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)); + nano::block_builder builder; + auto send = builder + .send () + .previous (latest) + .destination (nano::dev::genesis->account ()) + .balance (100) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node1->work_generate_blocking (latest)) + .build (); { auto transaction (node1->store.tx_begin_write ()); - ASSERT_EQ (nano::process_result::progress, node1->ledger.process (transaction, send).code); + ASSERT_EQ (nano::process_result::progress, node1->ledger.process (transaction, *send).code); } auto const rpc_ctx = add_rpc (system0, node); boost::property_tree::ptree request; @@ -3046,10 +3333,18 @@ TEST (rpc, bootstrap_any) 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::dev::genesis->account (), 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system1.nodes[0]->work_generate_blocking (latest)); + nano::block_builder builder; + auto send = builder + .send () + .previous (latest) + .destination (nano::dev::genesis->account ()) + .balance (100) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system1.nodes[0]->work_generate_blocking (latest)) + .build (); { auto transaction (system1.nodes[0]->store.tx_begin_write ()); - ASSERT_EQ (nano::process_result::progress, system1.nodes[0]->ledger.process (transaction, send).code); + ASSERT_EQ (nano::process_result::progress, system1.nodes[0]->ledger.process (transaction, *send).code); } auto const rpc_ctx = add_rpc (system0, node); boost::property_tree::ptree request; @@ -3066,14 +3361,29 @@ TEST (rpc, republish) 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); + nano::block_builder builder; + auto send = builder + .send () + .previous (latest) + .destination (key.pub) + .balance (100) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node1->work_generate_blocking (latest)) + .build (); + ASSERT_EQ (nano::process_result::progress, node1->process (*send).code); + auto open = builder + .open () + .source (send->hash ()) + .representative (key.pub) + .account (key.pub) + .sign (key.prv, key.pub) + .work (*node1->work_generate_blocking (key.pub)) + .build (); + ASSERT_EQ (nano::process_result::progress, node1->process (*open).code); auto const rpc_ctx = add_rpc (system, node1); boost::property_tree::ptree request; request.put ("action", "republish"); - request.put ("hash", send.hash ().to_string ()); + request.put ("hash", send->hash ().to_string ()); auto response (wait_response (system, rpc_ctx, 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")); @@ -3083,7 +3393,7 @@ TEST (rpc, republish) blocks.push_back (nano::block_hash (i->second.get (""))); } ASSERT_EQ (1, blocks.size ()); - ASSERT_EQ (send.hash (), blocks[0]); + ASSERT_EQ (send->hash (), blocks[0]); request.put ("hash", nano::dev::genesis->hash ().to_string ()); request.put ("count", 1); @@ -3097,7 +3407,7 @@ TEST (rpc, republish) ASSERT_EQ (1, blocks.size ()); ASSERT_EQ (nano::dev::genesis->hash (), blocks[0]); - request.put ("hash", open.hash ().to_string ()); + request.put ("hash", open->hash ().to_string ()); request.put ("sources", 2); auto response2 (wait_response (system, rpc_ctx, request)); blocks_node = response2.get_child ("blocks"); @@ -3108,8 +3418,8 @@ TEST (rpc, republish) } ASSERT_EQ (3, blocks.size ()); ASSERT_EQ (nano::dev::genesis->hash (), blocks[0]); - ASSERT_EQ (send.hash (), blocks[1]); - ASSERT_EQ (open.hash (), blocks[2]); + ASSERT_EQ (send->hash (), blocks[1]); + ASSERT_EQ (open->hash (), blocks[2]); } TEST (rpc, deterministic_key) @@ -3791,10 +4101,18 @@ TEST (rpc, search_receivable_all) 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::dev::constants.genesis_amount - node->config.receive_minimum.number (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node->work_generate_blocking (latest)); + nano::block_builder builder; + auto block = builder + .send () + .previous (latest) + .destination (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - node->config.receive_minimum.number ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node->work_generate_blocking (latest)) + .build (); { auto transaction (node->store.tx_begin_write ()); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, block).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *block).code); } auto const rpc_ctx = add_rpc (system, node); boost::property_tree::ptree request; @@ -3817,10 +4135,25 @@ TEST (rpc, wallet_republish) 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)); - 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); + nano::block_builder builder; + auto send = builder + .send () + .previous (latest) + .destination (key.pub) + .balance (100) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node1->work_generate_blocking (latest)) + .build (); + ASSERT_EQ (nano::process_result::progress, node1->process (*send).code); + auto open = builder + .open () + .source (send->hash ()) + .representative (key.pub) + .account (key.pub) + .sign (key.prv, key.pub) + .work (*node1->work_generate_blocking (key.pub)) + .build (); + ASSERT_EQ (nano::process_result::progress, node1->process (*open).code); auto const rpc_ctx = add_rpc (system, node1); boost::property_tree::ptree request; request.put ("action", "wallet_republish"); @@ -3834,8 +4167,8 @@ TEST (rpc, wallet_republish) blocks.emplace_back (i->second.get ("")); } ASSERT_EQ (2, blocks.size ()); - ASSERT_EQ (send.hash (), blocks[0]); - ASSERT_EQ (open.hash (), blocks[1]); + ASSERT_EQ (send->hash (), blocks[0]); + ASSERT_EQ (open->hash (), blocks[1]); } TEST (rpc, delegators) @@ -3846,10 +4179,25 @@ TEST (rpc, delegators) 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)); - 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); + nano::block_builder builder; + auto send = builder + .send () + .previous (latest) + .destination (key.pub) + .balance (100) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node1->work_generate_blocking (latest)) + .build (); + ASSERT_EQ (nano::process_result::progress, node1->process (*send).code); + auto open = builder + .open () + .source (send->hash ()) + .representative (nano::dev::genesis_key.pub) + .account (key.pub) + .sign (key.prv, key.pub) + .work (*node1->work_generate_blocking (key.pub)) + .build (); + ASSERT_EQ (nano::process_result::progress, node1->process (*open).code); auto const rpc_ctx = add_rpc (system, node1); boost::property_tree::ptree request; request.put ("action", "delegators"); @@ -3872,10 +4220,25 @@ TEST (rpc, delegators_parameters) 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); + nano::block_builder builder; + auto send = builder + .send () + .previous (latest) + .destination (key.pub) + .balance (100) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node1->work_generate_blocking (latest)) + .build (); + ASSERT_EQ (nano::process_result::progress, node1->process (*send).code); + auto open = builder + .open () + .source (send->hash ()) + .representative (nano::dev::genesis_key.pub) + .account (key.pub) + .sign (key.prv, key.pub) + .work (*node1->work_generate_blocking (key.pub)) + .build (); + ASSERT_EQ (nano::process_result::progress, node1->process (*open).code); auto const rpc_ctx = add_rpc (system, node1); // Test with "count" = 2 @@ -3967,10 +4330,25 @@ TEST (rpc, delegators_count) 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)); - 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); + nano::block_builder builder; + auto send = builder + .send () + .previous (latest) + .destination (key.pub) + .balance (100) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node1->work_generate_blocking (latest)) + .build (); + ASSERT_EQ (nano::process_result::progress, node1->process (*send).code); + auto open = builder + .open () + .source (send->hash ()) + .representative (nano::dev::genesis_key.pub) + .account (key.pub) + .sign (key.prv, key.pub) + .work (*node1->work_generate_blocking (key.pub)) + .build (); + ASSERT_EQ (nano::process_result::progress, node1->process (*open).code); auto const rpc_ctx = add_rpc (system, node1); boost::property_tree::ptree request; request.put ("action", "delegators_count"); @@ -4005,8 +4383,16 @@ TEST (rpc, account_info) 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)); - ASSERT_EQ (nano::process_result::progress, node1->process (send).code); + nano::block_builder builder; + auto send = builder + .send () + .previous (latest) + .destination (key.pub) + .balance (100) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node1->work_generate_blocking (latest)) + .build (); + ASSERT_EQ (nano::process_result::progress, node1->process (*send).code); auto time (nano::seconds_since_epoch ()); { auto transaction = node1->store.tx_begin_write (); @@ -4018,7 +4404,7 @@ TEST (rpc, account_info) { auto response (wait_response (system, rpc_ctx, request)); std::string frontier (response.get ("frontier")); - ASSERT_EQ (send.hash ().to_string (), frontier); + ASSERT_EQ (send->hash ().to_string (), frontier); 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")); @@ -4059,16 +4445,46 @@ TEST (rpc, account_info) 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)); - 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 ())); - 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)); - ASSERT_EQ (nano::process_result::progress, node1->process (open).code); + auto send1 = builder + .send () + .previous (latest) + .destination (key1.pub) + .balance (50) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node1->work_generate_blocking (latest)) + .build (); + ASSERT_EQ (nano::process_result::progress, node1->process (*send1).code); + auto send2 = builder + .send () + .previous (send1->hash ()) + .destination (key1.pub) + .balance (25) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node1->work_generate_blocking (send1->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, node1->process (*send2).code); + + auto state_change = builder + .state () + .account (nano::dev::genesis_key.pub) + .previous (send2->hash ()) + .representative (key1.pub) + .balance (25) + .link (0) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node1->work_generate_blocking (send2->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, node1->process (*state_change).code); + + auto open = builder + .open () + .source (send1->hash ()) + .representative (nano::dev::genesis_key.pub) + .account (key1.pub) + .sign (key1.prv, key1.pub) + .work (*node1->work_generate_blocking (key1.pub)) + .build (); + ASSERT_EQ (nano::process_result::progress, node1->process (*open).code); } rpc_ctx.io_scope->renew (); @@ -4137,7 +4553,17 @@ TEST (rpc, json_block_input) 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::Gxrb_ratio, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0); + nano::block_builder builder; + auto send = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (node1->latest (nano::dev::genesis_key.pub)) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .link (key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (0) + .build (); auto const rpc_ctx = add_rpc (system, node1); boost::property_tree::ptree request; request.put ("action", "sign"); @@ -4147,7 +4573,7 @@ TEST (rpc, json_block_input) request.put ("wallet", wallet); request.put ("account", key.pub.to_account ()); boost::property_tree::ptree json; - send.serialize_json (json); + send->serialize_json (json); request.add_child ("block", json); auto response (wait_response (system, rpc_ctx, request, 10s)); @@ -4155,9 +4581,9 @@ TEST (rpc, json_block_input) 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 ())); - ASSERT_NE (block.block_signature (), send.block_signature ()); - ASSERT_EQ (block.hash (), send.hash ()); + ASSERT_FALSE (nano::validate_message (key.pub, send->hash (), block.block_signature ())); + ASSERT_NE (block.block_signature (), send->block_signature ()); + ASSERT_EQ (block.hash (), send->hash ()); } /** Make sure we can receive json block literals instead of string as output */ @@ -4167,13 +4593,21 @@ TEST (rpc, json_block_output) 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::block_builder builder; + auto send = builder + .send () + .previous (latest) + .destination (key.pub) + .balance (100) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node1->work_generate_blocking (latest)) + .build (); + ASSERT_EQ (nano::process_result::progress, node1->process (*send).code); auto const 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 ()); + request.put ("hash", send->hash ().to_string ()); auto response (wait_response (system, rpc_ctx, request)); // Make sure contents contains a valid JSON subtree instread of stringified json @@ -4381,8 +4815,16 @@ TEST (rpc, block_info_successor) 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::block_builder builder; + auto send = builder + .send () + .previous (latest) + .destination (key.pub) + .balance (100) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node1->work_generate_blocking (latest)) + .build (); + ASSERT_EQ (nano::process_result::progress, node1->process (*send).code); auto const rpc_ctx = add_rpc (system, node1); boost::property_tree::ptree request; request.put ("action", "block_info"); @@ -4391,7 +4833,7 @@ TEST (rpc, block_info_successor) // Make sure send block is successor of genesis std::string successor_text (response.get ("successor")); - ASSERT_EQ (successor_text, send.hash ().to_string ()); + 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")); @@ -4410,9 +4852,23 @@ TEST (rpc, block_info_pruning) 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::dev::constants.genesis_amount - nano::Gxrb_ratio, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node1->work_generate_blocking (latest))); + nano::block_builder builder; + auto send1 = builder + .send () + .previous (latest) + .destination (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node1->work_generate_blocking (latest)) + .build_shared (); 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 ()))); + auto receive1 = builder + .receive () + .previous (send1->hash ()) + .source (send1->hash ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node1->work_generate_blocking (send1->hash ())) + .build_shared (); node1->process_active (receive1); node1->block_processor.flush (); system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); @@ -4463,9 +4919,23 @@ TEST (rpc, pruned_exists) 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::dev::constants.genesis_amount - nano::Gxrb_ratio, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node1->work_generate_blocking (latest))); + nano::block_builder builder; + auto send1 = builder + .send () + .previous (latest) + .destination (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node1->work_generate_blocking (latest)) + .build_shared (); 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 ()))); + auto receive1 = builder + .receive () + .previous (send1->hash ()) + .source (send1->hash ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node1->work_generate_blocking (send1->hash ())) + .build_shared (); node1->process_active (receive1); node1->block_processor.flush (); system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); @@ -4533,10 +5003,25 @@ TEST (rpc, ledger) 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, *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); + nano::block_builder builder; + auto send = builder + .send () + .previous (latest) + .destination (key.pub) + .balance (genesis_balance) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node->work_generate_blocking (latest)) + .build (); + ASSERT_EQ (nano::process_result::progress, node->process (*send).code); + auto open = builder + .open () + .source (send->hash ()) + .representative (nano::dev::genesis_key.pub) + .account (key.pub) + .sign (key.prv, key.pub) + .work (*node->work_generate_blocking (key.pub)) + .build (); + ASSERT_EQ (nano::process_result::progress, node->process (*open).code); auto time (nano::seconds_since_epoch ()); auto const rpc_ctx = add_rpc (system, node); boost::property_tree::ptree request; @@ -4550,11 +5035,11 @@ TEST (rpc, ledger) std::string account_text (account.first); ASSERT_EQ (key.pub.to_account (), account_text); std::string frontier (account.second.get ("frontier")); - ASSERT_EQ (open.hash ().to_string (), frontier); + ASSERT_EQ (open->hash ().to_string (), frontier); std::string open_block (account.second.get ("open_block")); - ASSERT_EQ (open.hash ().to_string (), open_block); + ASSERT_EQ (open->hash ().to_string (), open_block); std::string representative_block (account.second.get ("representative_block")); - ASSERT_EQ (open.hash ().to_string (), representative_block); + ASSERT_EQ (open->hash ().to_string (), representative_block); std::string balance_text (account.second.get ("balance")); ASSERT_EQ (send_amount.convert_to (), balance_text); std::string modified_timestamp (account.second.get ("modified_timestamp")); @@ -4602,9 +5087,16 @@ 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, *node->work_generate_blocking (send.hash ())); + auto send2 = builder + .send () + .previous (send->hash ()) + .destination (key.pub) + .balance (genesis_balance) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node->work_generate_blocking (send->hash ())) + .build (); rpc_ctx.io_scope->reset (); - ASSERT_EQ (nano::process_result::progress, node->process (send2).code); + 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); @@ -4653,9 +5145,24 @@ TEST (rpc, block_create) 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); + nano::block_builder builder; + auto send = builder + .send () + .previous (latest) + .destination (key.pub) + .balance (100) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (send_work) + .build (); 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 open = builder + .open () + .source (send->hash ()) + .representative (nano::dev::genesis_key.pub) + .account (key.pub) + .sign (key.prv, key.pub) + .work (open_work) + .build (); auto const rpc_ctx = add_rpc (system, node1); boost::property_tree::ptree request; request.put ("action", "block_create"); @@ -4668,17 +5175,17 @@ TEST (rpc, block_create) request.put ("work", nano::to_string_hex (send_work)); auto response (wait_response (system, rpc_ctx, request)); std::string send_hash (response.get ("hash")); - ASSERT_EQ (send.hash ().to_string (), send_hash); + ASSERT_EQ (send->hash ().to_string (), send_hash); std::string send_difficulty (response.get ("difficulty")); - ASSERT_EQ (nano::to_string_hex (nano::dev::network_params.work.difficulty (send)), send_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 ()); + ASSERT_EQ (send->hash (), send_block->hash ()); rpc_ctx.io_scope->reset (); - ASSERT_EQ (nano::process_result::progress, node1->process (send).code); + 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"); @@ -4687,48 +5194,61 @@ TEST (rpc, block_create) key.prv.encode_hex (key_text); request1.put ("key", key_text); request1.put ("representative", nano::dev::genesis_key.pub.to_account ()); - request1.put ("source", send.hash ().to_string ()); + request1.put ("source", send->hash ().to_string ()); request1.put ("work", nano::to_string_hex (open_work)); auto response1 (wait_response (system, rpc_ctx, request1)); std::string open_hash (response1.get ("hash")); - ASSERT_EQ (open.hash ().to_string (), open_hash); + ASSERT_EQ (open->hash ().to_string (), open_hash); 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 ()); + ASSERT_EQ (open->hash (), open_block->hash ()); rpc_ctx.io_scope->reset (); - ASSERT_EQ (nano::process_result::progress, node1->process (open).code); + ASSERT_EQ (nano::process_result::progress, node1->process (*open).code); rpc_ctx.io_scope->renew (); request1.put ("representative", key.pub.to_account ()); auto response2 (wait_response (system, rpc_ctx, 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 ()); - nano::change_block change (open.hash (), key.pub, key.prv, key.pub, change_work); + ASSERT_NE (open->hash ().to_string (), open2_hash); // different blocks with wrong representative + auto change_work = *node1->work_generate_blocking (open->hash ()); + auto change = builder + .change () + .previous (open->hash ()) + .representative (key.pub) + .sign (key.prv, key.pub) + .work (change_work) + .build (); request1.put ("type", "change"); request1.put ("work", nano::to_string_hex (change_work)); auto response4 (wait_response (system, rpc_ctx, request1)); std::string change_hash (response4.get ("hash")); - ASSERT_EQ (change.hash ().to_string (), change_hash); + ASSERT_EQ (change->hash ().to_string (), change_hash); 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 ()); + ASSERT_EQ (change->hash (), change_block->hash ()); 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); + ASSERT_EQ (nano::process_result::progress, node1->process (*change).code); + auto send2 = builder + .send () + .previous (send->hash ()) + .destination (key.pub) + .balance (0) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node1->work_generate_blocking (send->hash ())) + .build (); + 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 ("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 ()))); + 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 ()))); auto response5 (wait_response (system, rpc_ctx, request2)); std::string receive_hash (response4.get ("hash")); auto receive_text (response5.get ("block")); @@ -4902,8 +5422,18 @@ TEST (rpc, block_create_receive_epoch_v2) 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::Gxrb_ratio)); ASSERT_NE (nullptr, send_block); - nano::state_block open (key.pub, 0, nano::dev::genesis_key.pub, nano::Gxrb_ratio, send_block->hash (), key.prv, key.pub, *node->work_generate_blocking (key.pub)); - ASSERT_EQ (nano::process_result::progress, node->process (open).code); + nano::block_builder builder; + auto open = builder + .state () + .account (key.pub) + .previous (0) + .representative (nano::dev::genesis_key.pub) + .balance (nano::Gxrb_ratio) + .link (send_block->hash ()) + .sign (key.prv, key.pub) + .work (*node->work_generate_blocking (key.pub)) + .build (); + 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::Gxrb_ratio)); auto const rpc_ctx = add_rpc (system, node); @@ -4912,7 +5442,7 @@ TEST (rpc, block_create_receive_epoch_v2) 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 ("previous", open->hash ().to_string ()); request.put ("representative", nano::dev::genesis_key.pub.to_account ()); request.put ("balance", (2 * nano::Gxrb_ratio).convert_to ()); request.put ("link", send_block_2->hash ().to_string ()); @@ -4946,15 +5476,25 @@ TEST (rpc, block_create_send_epoch_v2) 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::Gxrb_ratio)); ASSERT_NE (nullptr, send_block); - nano::state_block open (key.pub, 0, nano::dev::genesis_key.pub, nano::Gxrb_ratio, send_block->hash (), key.prv, key.pub, *node->work_generate_blocking (key.pub)); - ASSERT_EQ (nano::process_result::progress, node->process (open).code); + nano::block_builder builder; + auto open = builder + .state () + .account (key.pub) + .previous (0) + .representative (nano::dev::genesis_key.pub) + .balance (nano::Gxrb_ratio) + .link (send_block->hash ()) + .sign (key.prv, key.pub) + .work (*node->work_generate_blocking (key.pub)) + .build (); + ASSERT_EQ (nano::process_result::progress, node->process (*open).code); auto const 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 ("previous", open->hash ().to_string ()); request.put ("representative", nano::dev::genesis_key.pub.to_account ()); request.put ("balance", 0); request.put ("link", nano::dev::genesis_key.pub.to_string ()); @@ -4985,15 +5525,23 @@ TEST (rpc, block_hash) auto const 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::block_builder builder; + auto send = builder + .send () + .previous (latest) + .destination (key.pub) + .balance (100) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node1->work_generate_blocking (latest)) + .build (); boost::property_tree::ptree request; request.put ("action", "block_hash"); std::string json; - send.serialize_json (json); + send->serialize_json (json); request.put ("block", json); auto response (wait_response (system, rpc_ctx, request)); std::string send_hash (response.get ("hash")); - ASSERT_EQ (send.hash ().to_string (), send_hash); + ASSERT_EQ (send->hash ().to_string (), send_hash); } TEST (rpc, wallet_lock) @@ -5055,10 +5603,25 @@ TEST (rpc, wallet_ledger) nano::keypair key; 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)); - 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); + nano::block_builder builder; + auto send = builder + .send () + .previous (latest) + .destination (key.pub) + .balance (100) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node1->work_generate_blocking (latest)) + .build (); + ASSERT_EQ (nano::process_result::progress, node1->process (*send).code); + auto open = builder + .open () + .source (send->hash ()) + .representative (nano::dev::genesis_key.pub) + .account (key.pub) + .sign (key.prv, key.pub) + .work (*node1->work_generate_blocking (key.pub)) + .build (); + ASSERT_EQ (nano::process_result::progress, node1->process (*open).code); auto time (nano::seconds_since_epoch ()); auto const rpc_ctx = add_rpc (system, node1); boost::property_tree::ptree request; @@ -5072,11 +5635,11 @@ TEST (rpc, wallet_ledger) std::string account_text (accounts.first); ASSERT_EQ (key.pub.to_account (), account_text); std::string frontier (accounts.second.get ("frontier")); - ASSERT_EQ (open.hash ().to_string (), frontier); + ASSERT_EQ (open->hash ().to_string (), frontier); std::string open_block (accounts.second.get ("open_block")); - ASSERT_EQ (open.hash ().to_string (), open_block); + ASSERT_EQ (open->hash ().to_string (), open_block); std::string representative_block (accounts.second.get ("representative_block")); - ASSERT_EQ (open.hash ().to_string (), representative_block); + ASSERT_EQ (open->hash ().to_string (), representative_block); std::string balance_text (accounts.second.get ("balance")); ASSERT_EQ ("340282366920938463463374607431768211355", balance_text); std::string modified_timestamp (accounts.second.get ("modified_timestamp")); @@ -5219,9 +5782,17 @@ TEST (rpc, confirmation_height_currently_processing) { auto transaction = node->store.tx_begin_write (); nano::keypair key1; - nano::send_block send (previous_genesis_chain_hash, key1.pub, nano::dev::constants.genesis_amount - nano::Gxrb_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 (); + nano::block_builder builder; + auto send = builder + .send () + .previous (previous_genesis_chain_hash) + .destination (key1.pub) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio - 1) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (previous_genesis_chain_hash)) + .build (); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code); + previous_genesis_chain_hash = send->hash (); } std::shared_ptr frontier; @@ -5329,7 +5900,17 @@ TEST (rpc, block_confirm) nano::system system; auto node = add_ipc_enabled_node (system); 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::Gxrb_ratio, nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node->work_generate_blocking (nano::dev::genesis->hash ()))); + nano::block_builder builder; + auto send1 = builder + .state () + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_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 transaction (node->store.tx_begin_write ()); ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send1).code); @@ -5425,8 +6006,27 @@ TEST (rpc, unchecked) auto node = add_ipc_enabled_node (system); auto const rpc_ctx = add_rpc (system, node); nano::keypair key{}; - 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)); + nano::block_builder builder; + auto open = builder + .state () + .account (key.pub) + .previous (0) + .representative (key.pub) + .balance (1) + .link (key.pub) + .sign (key.prv, key.pub) + .work (*system.work.generate (key.pub)) + .build_shared (); + auto open2 = builder + .state () + .account (key.pub) + .previous (0) + .representative (key.pub) + .balance (2) + .link (key.pub) + .sign (key.prv, key.pub) + .work (*system.work.generate (key.pub)) + .build_shared (); node->process_active (open); node->process_active (open2); // Waits for the last block of the queue to get saved in the database @@ -5458,7 +6058,17 @@ TEST (rpc, unchecked_get) auto node = add_ipc_enabled_node (system); auto const rpc_ctx = add_rpc (system, node); nano::keypair key{}; - auto open = std::make_shared (key.pub, 0, key.pub, 1, key.pub, key.prv, key.pub, *system.work.generate (key.pub)); + nano::block_builder builder; + auto open = builder + .state () + .account (key.pub) + .previous (0) + .representative (key.pub) + .balance (1) + .link (key.pub) + .sign (key.prv, key.pub) + .work (*system.work.generate (key.pub)) + .build_shared (); node->process_active (open); // Waits for the open block to get saved in the database ASSERT_TIMELY (10s, 1 == node->unchecked.count (node->store.tx_begin_read ())); @@ -5487,7 +6097,17 @@ TEST (rpc, unchecked_clear) auto node = add_ipc_enabled_node (system); auto const rpc_ctx = add_rpc (system, node); nano::keypair key{}; - auto open = std::make_shared (key.pub, 0, key.pub, 1, key.pub, key.prv, key.pub, *system.work.generate (key.pub)); + nano::block_builder builder; + auto open = builder + .state () + .account (key.pub) + .previous (0) + .representative (key.pub) + .balance (1) + .link (key.pub) + .sign (key.prv, key.pub) + .work (*system.work.generate (key.pub)) + .build_shared (); node->process_active (open); boost::property_tree::ptree request{}; // Waits for the open block to get saved in the database @@ -5667,11 +6287,21 @@ TEST (rpc, sign_hash) nano::system system; auto node1 = add_ipc_enabled_node (system); nano::keypair key; - 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::Gxrb_ratio, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0); + nano::block_builder builder; + auto send = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (node1->latest (nano::dev::genesis_key.pub)) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .link (key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (0) + .build (); auto const rpc_ctx = add_rpc (system, node1); boost::property_tree::ptree request; request.put ("action", "sign"); - request.put ("hash", send.hash ().to_string ()); + request.put ("hash", send->hash ().to_string ()); request.put ("key", key.prv.to_string ()); auto response (wait_response (system, rpc_ctx, request, 10s)); std::error_code ec (nano::error_rpc::sign_hash_disabled); @@ -5681,7 +6311,7 @@ TEST (rpc, sign_hash) nano::signature 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)); + ASSERT_FALSE (nano::validate_message (key.pub, send->hash (), signature)); } TEST (rpc, sign_block) @@ -5690,7 +6320,17 @@ TEST (rpc, sign_block) 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::Gxrb_ratio, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0); + nano::block_builder builder; + auto send = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (node1->latest (nano::dev::genesis_key.pub)) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .link (key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (0) + .build (); auto const rpc_ctx = add_rpc (system, node1); boost::property_tree::ptree request; request.put ("action", "sign"); @@ -5699,7 +6339,7 @@ TEST (rpc, sign_block) request.put ("wallet", wallet); request.put ("account", key.pub.to_account ()); std::string json; - send.serialize_json (json); + send->serialize_json (json); request.put ("block", json); auto response (wait_response (system, rpc_ctx, request, 10s)); auto contents (response.get ("block")); @@ -5707,9 +6347,9 @@ TEST (rpc, sign_block) std::stringstream block_stream (contents); boost::property_tree::read_json (block_stream, block_l); auto block (nano::deserialize_block_json (block_l)); - ASSERT_FALSE (nano::validate_message (key.pub, send.hash (), block->block_signature ())); - ASSERT_NE (block->block_signature (), send.block_signature ()); - ASSERT_EQ (block->hash (), send.hash ()); + ASSERT_FALSE (nano::validate_message (key.pub, send->hash (), block->block_signature ())); + ASSERT_NE (block->block_signature (), send->block_signature ()); + ASSERT_EQ (block->hash (), send->hash ()); } TEST (rpc, memory_stats) @@ -5720,7 +6360,17 @@ TEST (rpc, memory_stats) // 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)); + nano::block_builder builder; + auto block = builder + .state () + .account (0) + .previous (0) + .representative (0) + .balance (0) + .link (0) + .sign (key.prv, key.pub) + .work (0) + .build_shared (); std::vector hashes; hashes.push_back (block->hash ()); auto vote (std::make_shared (key.pub, key.prv, 0, 0, hashes)); @@ -5758,16 +6408,31 @@ TEST (rpc, block_confirmed) rpc_ctx.io_scope->reset (); nano::keypair key; + nano::block_builder builder; // 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)); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send1).code); + auto send1 = builder + .send () + .previous (latest) + .destination (key.pub) + .balance (300) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (latest)) + .build (); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send1).code); - 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); + auto open1 = builder + .open () + .source (send1->hash ()) + .representative (nano::dev::genesis->account ()) + .account (key.pub) + .sign (key.prv, key.pub) + .work (*system.work.generate (key.pub)) + .build (); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *open1).code); } rpc_ctx.io_scope->renew (); @@ -5778,7 +6443,14 @@ TEST (rpc, block_confirmed) 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 = builder + .send () + .previous (latest) + .destination (key.pub) + .balance (10) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (latest)) + .build_shared (); node->process_active (send); node->block_processor.flush (); node->block_confirm (send); @@ -6039,16 +6711,62 @@ TEST (rpc, epoch_upgrade) 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::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 + nano::block_builder builder; + auto send1 = builder + .state () + .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 (*system.work.generate (nano::dev::genesis->hash ())) + .build_shared (); // 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::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) + auto send2 = builder + .state () + .account (nano::dev::genesis_key.pub) + .previous (send1->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - 2) + .link (key2.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (send1->hash ())) + .build_shared (); // 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::dev::constants.genesis_amount - 3, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send2->hash ()))); // to burn (0) + auto send3 = builder + .state () + .account (nano::dev::genesis_key.pub) + .previous (send2->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - 3) + .link (0) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (send2->hash ())) + .build_shared (); // 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::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 + auto send4 = builder + .state () + .account (nano::dev::genesis_key.pub) + .previous (send3->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - 4) + .link (max_account) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (send3->hash ())) + .build_shared (); // 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))); + auto open = builder + .state () + .account (key1.pub) + .previous (0) + .representative (key1.pub) + .balance (1) + .link (send1->hash ()) + .sign (key1.prv, key1.pub) + .work (*system.work.generate (key1.pub)) + .build_shared (); ASSERT_EQ (nano::process_result::progress, node->process (*open).code); // Check accounts epochs { @@ -6086,12 +6804,39 @@ TEST (rpc, epoch_upgrade) 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::dev::constants.genesis_amount - 5, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (genesis_latest))); // to burn (0) + auto send5 = builder + .state () + .account (nano::dev::genesis_key.pub) + .previous (genesis_latest) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - 5) + .link (0) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (genesis_latest)) + .build_shared (); // 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::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) + auto send6 = builder + .state () + .account (nano::dev::genesis_key.pub) + .previous (send5->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - 6) + .link (key1.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (send5->hash ())) + .build_shared (); // 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 + auto send7 = builder + .state () + .account (key1.pub) + .previous (key1_latest) + .representative (key1.pub) + .balance (0) + .link (key3.pub) + .sign (key1.prv, key1.pub) + .work (*system.work.generate (key1_latest)) + .build_shared (); // to key3 ASSERT_EQ (nano::process_result::progress, node->process (*send7).code); { // Check pending entry @@ -6131,16 +6876,62 @@ TEST (rpc, epoch_upgrade_multithreaded) 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::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 + nano::block_builder builder; + auto send1 = builder + .state () + .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 (*system.work.generate (nano::dev::genesis->hash ())) + .build_shared (); // 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::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) + auto send2 = builder + .state () + .account (nano::dev::genesis_key.pub) + .previous (send1->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - 2) + .link (key2.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (send1->hash ())) + .build_shared (); // 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::dev::constants.genesis_amount - 3, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send2->hash ()))); // to burn (0) + auto send3 = builder + .state () + .account (nano::dev::genesis_key.pub) + .previous (send2->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - 3) + .link (0) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (send2->hash ())) + .build_shared (); // 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::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 + auto send4 = builder + .state () + .account (nano::dev::genesis_key.pub) + .previous (send3->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - 4) + .link (max_account) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (send3->hash ())) + .build_shared (); // 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))); + auto open = builder + .state () + .account (key1.pub) + .previous (0) + .representative (key1.pub) + .balance (1) + .link (send1->hash ()) + .sign (key1.prv, key1.pub) + .work (*system.work.generate (key1.pub)) + .build_shared (); ASSERT_EQ (nano::process_result::progress, node->process (*open).code); // Check accounts epochs { @@ -6179,12 +6970,39 @@ TEST (rpc, epoch_upgrade_multithreaded) 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::dev::constants.genesis_amount - 5, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (genesis_latest))); // to burn (0) + auto send5 = builder + .state () + .account (nano::dev::genesis_key.pub) + .previous (genesis_latest) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - 5) + .link (0) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (genesis_latest)) + .build_shared (); // 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::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) + auto send6 = builder + .state () + .account (nano::dev::genesis_key.pub) + .previous (send5->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - 6) + .link (key1.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (send5->hash ())) + .build_shared (); // 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 + auto send7 = builder + .state () + .account (key1.pub) + .previous (key1_latest) + .representative (key1.pub) + .balance (0) + .link (key3.pub) + .sign (key1.prv, key1.pub) + .work (*system.work.generate (key1_latest)) + .build_shared (); // to key3 ASSERT_EQ (nano::process_result::progress, node->process (*send7).code); { // Check pending entry @@ -6223,10 +7041,27 @@ TEST (rpc, account_lazy_start) node_flags.disable_legacy_bootstrap = true; auto node1 = system.add_node (node_flags); nano::keypair key{}; + nano::block_builder builder; // Generating test chain - 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::Gxrb_ratio, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (nano::dev::genesis->hash ())); + auto send1 = builder + .state () + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .link (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 (*send1).code); - auto open = std::make_shared (send1->hash (), key.pub, key.pub, key.prv, key.pub, *system.work.generate (key.pub)); + auto open = builder + .open () + .source (send1->hash ()) + .representative (key.pub) + .account (key.pub) + .sign (key.prv, key.pub) + .work (*system.work.generate (key.pub)) + .build_shared (); ASSERT_EQ (nano::process_result::progress, node1->process (*open).code); // Start lazy bootstrap with account @@ -6614,8 +7449,23 @@ TEST (rpc, confirmation_active) auto node1 (system.add_node (node_config, node_flags)); auto const 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 ()))); + nano::block_builder builder; + auto send1 = builder + .send () + .previous (nano::dev::genesis->hash ()) + .destination (nano::public_key ()) + .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 + .send () + .previous (send1->hash ()) + .destination (nano::public_key ()) + .balance (nano::dev::constants.genesis_amount - 200) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (send1->hash ())) + .build_shared (); node1->process_active (send1); node1->process_active (send2); nano::blocks_confirm (*node1, { send1, send2 }); @@ -6642,7 +7492,15 @@ TEST (rpc, confirmation_info) auto node1 = add_ipc_enabled_node (system); auto const rpc_ctx = add_rpc (system, node1); - 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 ()))); + nano::block_builder builder; + auto send = builder + .send () + .previous (nano::dev::genesis->hash ()) + .destination (nano::public_key ()) + .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); ASSERT_TIMELY (5s, !node1->active.empty ()); diff --git a/nano/slow_test/node.cpp b/nano/slow_test/node.cpp index 0d58f84c9a..92dab69a70 100644 --- a/nano/slow_test/node.cpp +++ b/nano/slow_test/node.cpp @@ -124,21 +124,49 @@ TEST (ledger, deep_account_compute) nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key; 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)); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, open).code); - auto sprevious (send.hash ()); - auto rprevious (open.hash ()); + nano::block_builder builder; + auto send = builder + .send () + .previous (nano::dev::genesis->hash ()) + .destination (key.pub) + .balance (balance) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send).code); + auto open = builder + .open () + .source (send->hash ()) + .representative (nano::dev::genesis_key.pub) + .account (key.pub) + .sign (key.prv, key.pub) + .work (*pool.generate (key.pub)) + .build (); + 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)); - 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)); - ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, receive).code); - rprevious = receive.hash (); + auto send = builder + .send () + .previous (sprevious) + .destination (key.pub) + .balance (balance) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (sprevious)) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send).code); + sprevious = send->hash (); + auto receive = builder + .receive () + .previous (rprevious) + .source (send->hash ()) + .sign (key.prv, key.pub) + .work (*pool.generate (rprevious)) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *receive).code); + rprevious = receive->hash (); if (i % 100 == 0) { std::cerr << i << ' '; @@ -227,19 +255,34 @@ TEST (node, fork_storm) 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 ()); + nano::block_builder builder; for (auto node_j : system.nodes) { balance -= 1; nano::keypair key; - nano::send_block send (previous, key.pub, balance, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0); - node_j->work_generate_blocking (send); - previous = send.hash (); + auto send = builder + .send () + .previous (previous) + .destination (key.pub) + .balance (balance) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (0) + .build (); + node_j->work_generate_blocking (*send); + previous = send->hash (); for (auto node_i : system.nodes) { - auto send_result (node_i->process (send)); + auto send_result (node_i->process (*send)); ASSERT_EQ (nano::process_result::progress, send_result.code); nano::keypair rep; - auto open (std::make_shared (previous, rep.pub, key.pub, key.prv, key.pub, 0)); + auto open = builder + .open () + .source (previous) + .representative (rep.pub) + .account (key.pub) + .sign (key.prv, key.pub) + .work (0) + .build_shared (); node_i->work_generate_blocking (*open); auto open_result (node_i->process (*open)); ASSERT_EQ (nano::process_result::progress, open_result.code); @@ -450,7 +493,15 @@ TEST (store, unchecked_load) { nano::system system{ 1 }; auto & node = *system.nodes[0]; - std::shared_ptr block = std::make_shared (0, 0, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0); + nano::block_builder builder; + std::shared_ptr block = builder + .send () + .previous (0) + .destination (0) + .balance (0) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (0) + .build_shared (); constexpr auto num_unchecked = 1'000'000; for (auto i (0); i < num_unchecked; ++i) { @@ -549,9 +600,19 @@ TEST (node, mass_vote_by_hash) nano::block_hash previous (nano::dev::genesis->hash ()); nano::keypair key; std::vector> blocks; + nano::block_builder builder; for (auto i (0); i < 10000; ++i) { - auto block (std::make_shared (nano::dev::genesis_key.pub, previous, nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - (i + 1) * nano::Gxrb_ratio, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (previous))); + auto block = builder + .state () + .account (nano::dev::genesis_key.pub) + .previous (previous) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - (i + 1) * nano::Gxrb_ratio) + .link (key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (previous)) + .build_shared (); previous = block->hash (); blocks.push_back (block); } @@ -576,6 +637,7 @@ TEST (confirmation_height, many_accounts_single_confirmation) 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; + nano::block_builder builder; auto last_open_hash = node->latest (nano::dev::genesis_key.pub); { auto transaction = node->store.tx_begin_write (); @@ -584,11 +646,25 @@ TEST (confirmation_height, many_accounts_single_confirmation) nano::keypair key; system.wallet (0)->insert_adhoc (key.prv); - nano::send_block send (last_open_hash, key.pub, node->online_reps.delta (), last_keypair.prv, last_keypair.pub, *system.work.generate (last_open_hash)); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send).code); - nano::open_block open (send.hash (), last_keypair.pub, key.pub, key.prv, key.pub, *system.work.generate (key.pub)); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, open).code); - last_open_hash = open.hash (); + auto send = builder + .send () + .previous (last_open_hash) + .destination (key.pub) + .balance (node->online_reps.delta ()) + .sign (last_keypair.prv, last_keypair.pub) + .work (*system.work.generate (last_open_hash)) + .build (); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code); + auto open = builder + .open () + .source (send->hash ()) + .representative (last_keypair.pub) + .account (key.pub) + .sign (key.prv, key.pub) + .work (*system.work.generate (key.pub)) + .build (); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *open).code); + last_open_hash = open->hash (); last_keypair = key; } } @@ -645,6 +721,7 @@ TEST (confirmation_height, many_accounts_many_confirmations) 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); + nano::block_builder builder; std::vector> open_blocks; { auto transaction = node->store.tx_begin_write (); @@ -653,12 +730,26 @@ 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)); - 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 send = builder + .send () + .previous (latest_genesis) + .destination (key.pub) + .balance (node->online_reps.delta ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (latest_genesis)) + .build (); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code); + auto open = builder + .open () + .source (send->hash ()) + .representative (nano::dev::genesis_key.pub) + .account (key.pub) + .sign (key.prv, key.pub) + .work (*system.work.generate (key.pub)) + .build_shared (); ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *open).code); open_blocks.push_back (std::move (open)); - latest_genesis = send.hash (); + latest_genesis = send->hash (); } } @@ -709,45 +800,98 @@ TEST (confirmation_height, long_chains) node->confirmation_height_processor.batch_write_size = 500; auto const num_blocks = nano::confirmation_height::unbounded_cutoff * 2 + 50; + nano::block_builder builder; // First open the other account - nano::send_block send (latest, key1.pub, nano::dev::constants.genesis_amount - nano::Gxrb_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 send = builder + .send () + .previous (latest) + .destination (key1.pub) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio + num_blocks + 1) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (latest)) + .build (); + auto open = builder + .open () + .source (send->hash ()) + .representative (nano::dev::genesis->account ()) + .account (key1.pub) + .sign (key1.prv, key1.pub) + .work (*system.work.generate (key1.pub)) + .build (); { auto transaction = node->store.tx_begin_write (); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, open).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *open).code); } // Bulk send from genesis account to destination account - auto previous_genesis_chain_hash = send.hash (); - auto previous_destination_chain_hash = open.hash (); + auto previous_genesis_chain_hash = send->hash (); + auto previous_destination_chain_hash = open->hash (); { 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::dev::constants.genesis_amount - nano::Gxrb_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); - - previous_genesis_chain_hash = send.hash (); - previous_destination_chain_hash = receive.hash (); + auto send = builder + .send () + .previous (previous_genesis_chain_hash) + .destination (key1.pub) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio + i + 1) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (previous_genesis_chain_hash)) + .build (); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code); + auto receive = builder + .receive () + .previous (previous_destination_chain_hash) + .source (send->hash ()) + .sign (key1.prv, key1.pub) + .work (*system.work.generate (previous_destination_chain_hash)) + .build (); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *receive).code); + + previous_genesis_chain_hash = send->hash (); + previous_destination_chain_hash = receive->hash (); } } // Send one from destination to genesis and pocket it - nano::send_block send1 (previous_destination_chain_hash, nano::dev::genesis_key.pub, nano::Gxrb_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::Gxrb_ratio + 1, send1.hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (previous_genesis_chain_hash))); + auto send1 = builder + .send () + .previous (previous_destination_chain_hash) + .destination (nano::dev::genesis_key.pub) + .balance (nano::Gxrb_ratio - 2) + .sign (key1.prv, key1.pub) + .work (*system.work.generate (previous_destination_chain_hash)) + .build (); + auto receive1 = builder + .state () + .account (nano::dev::genesis_key.pub) + .previous (previous_genesis_chain_hash) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio + 1) + .link (send1->hash ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (previous_genesis_chain_hash)) + .build_shared (); // 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::dev::genesis->account (), receive1->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::Gxrb_ratio, key2.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (receive1->hash ())); + auto send2 = builder + .state () + .account (nano::dev::genesis->account ()) + .previous (receive1->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) + .link (key2.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (receive1->hash ())) + .build (); { auto transaction = node->store.tx_begin_write (); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send1).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send1).code); ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *receive1).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send2).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send2).code); } // Call block confirm on the existing receive block on the genesis account which will confirm everything underneath on both accounts @@ -799,9 +943,19 @@ TEST (confirmation_height, dynamic_algorithm) auto const num_blocks = nano::confirmation_height::unbounded_cutoff; auto latest_genesis = nano::dev::genesis; std::vector> state_blocks; + nano::block_builder builder; 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::dev::constants.genesis_amount - i - 1, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest_genesis->hash ()))); + auto send = builder + .state () + .account (nano::dev::genesis_key.pub) + .previous (latest_genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - i - 1) + .link (key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (latest_genesis->hash ())) + .build_shared (); latest_genesis = send; state_blocks.push_back (send); } @@ -857,7 +1011,17 @@ TEST (confirmation_height, dynamic_algorithm_no_transition_while_pending) 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::dev::constants.genesis_amount - num - 1, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest_genesis))); + nano::block_builder builder; + auto send = builder + .state () + .account (nano::dev::genesis_key.pub) + .previous (latest_genesis) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - num - 1) + .link (key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (latest_genesis)) + .build_shared (); latest_genesis = send->hash (); state_blocks.push_back (send); ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code); @@ -928,6 +1092,7 @@ TEST (confirmation_height, many_accounts_send_receive_self) auto latest_genesis = node->latest (nano::dev::genesis_key.pub); std::vector keys; + nano::block_builder builder; std::vector> open_blocks; { auto transaction = node->store.tx_begin_write (); @@ -936,12 +1101,26 @@ TEST (confirmation_height, many_accounts_send_receive_self) nano::keypair key; keys.emplace_back (key); - 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 send = builder + .send () + .previous (latest_genesis) + .destination (key.pub) + .balance (nano::dev::constants.genesis_amount - 1 - i) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (latest_genesis)) + .build (); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code); + auto open = builder + .open () + .source (send->hash ()) + .representative (nano::dev::genesis_key.pub) + .account (key.pub) + .sign (key.prv, key.pub) + .work (*system.work.generate (key.pub)) + .build_shared (); ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *open).code); open_blocks.push_back (std::move (open)); - latest_genesis = send.hash (); + latest_genesis = send->hash (); } } @@ -968,8 +1147,21 @@ TEST (confirmation_height, many_accounts_send_receive_self) { auto open_block = open_blocks[i]; auto & keypair = keys[i]; - send_blocks.emplace_back (std::make_shared (open_block->hash (), keypair.pub, 1, keypair.prv, keypair.pub, *system.work.generate (open_block->hash ()))); - receive_blocks.emplace_back (std::make_shared (send_blocks.back ()->hash (), send_blocks.back ()->hash (), keypair.prv, keypair.pub, *system.work.generate (send_blocks.back ()->hash ()))); + send_blocks.emplace_back (builder + .send () + .previous (open_block->hash ()) + .destination (keypair.pub) + .balance (1) + .sign (keypair.prv, keypair.pub) + .work (*system.work.generate (open_block->hash ())) + .build_shared ()); + receive_blocks.emplace_back (builder + .receive () + .previous (send_blocks.back ()->hash ()) + .source (send_blocks.back ()->hash ()) + .sign (keypair.prv, keypair.pub) + .work (*system.work.generate (send_blocks.back ()->hash ())) + .build_shared ()); } // Now send and receive to self @@ -1045,6 +1237,7 @@ TEST (confirmation_height, many_accounts_send_receive_self_no_elections) std::vector keys; std::vector> open_blocks; + nano::block_builder builder; nano::system system; { @@ -1056,12 +1249,26 @@ TEST (confirmation_height, many_accounts_send_receive_self_no_elections) { nano::keypair key; keys.emplace_back (key); - 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 send = builder + .send () + .previous (latest_genesis) + .destination (key.pub) + .balance (nano::dev::constants.genesis_amount - 1 - i) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (latest_genesis)) + .build (); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send).code); + auto open = builder + .open () + .source (send->hash ()) + .representative (nano::dev::genesis_key.pub) + .account (key.pub) + .sign (key.prv, key.pub) + .work (*pool.generate (key.pub)) + .build_shared (); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *open).code); open_blocks.push_back (std::move (open)); - latest_genesis = send.hash (); + latest_genesis = send->hash (); } } @@ -1087,8 +1294,21 @@ TEST (confirmation_height, many_accounts_send_receive_self_no_elections) { auto open_block = open_blocks[i]; auto & keypair = keys[i]; - send_blocks.emplace_back (std::make_shared (open_block->hash (), keypair.pub, 1, keypair.prv, keypair.pub, *system.work.generate (open_block->hash ()))); - receive_blocks.emplace_back (std::make_shared (send_blocks.back ()->hash (), send_blocks.back ()->hash (), keypair.prv, keypair.pub, *system.work.generate (send_blocks.back ()->hash ()))); + send_blocks.emplace_back (builder + .send () + .previous (open_block->hash ()) + .destination (keypair.pub) + .balance (1) + .sign (keypair.prv, keypair.pub) + .work (*system.work.generate (open_block->hash ())) + .build_shared ()); + receive_blocks.emplace_back (builder + .receive () + .previous (send_blocks.back ()->hash ()) + .source (send_blocks.back ()->hash ()) + .sign (keypair.prv, keypair.pub) + .work (*system.work.generate (send_blocks.back ()->hash ())) + .build_shared ()); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send_blocks.back ()).code); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *receive_blocks.back ()).code); @@ -1150,6 +1370,7 @@ TEST (confirmation_height, prioritize_frontiers_overwrite) node->store.confirmation_height.clear (transaction); } + nano::block_builder builder; { auto transaction = node->store.tx_begin_write (); for (auto i = num_accounts - 1; i > 0; --i) @@ -1157,11 +1378,25 @@ TEST (confirmation_height, prioritize_frontiers_overwrite) nano::keypair key; system.wallet (0)->insert_adhoc (key.prv); - nano::send_block send (last_open_hash, key.pub, nano::Gxrb_ratio - 1, last_keypair.prv, last_keypair.pub, *system.work.generate (last_open_hash)); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send).code); - nano::open_block open (send.hash (), last_keypair.pub, key.pub, key.prv, key.pub, *system.work.generate (key.pub)); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, open).code); - last_open_hash = open.hash (); + auto send = builder + .send () + .previous (last_open_hash) + .destination (key.pub) + .balance (nano::Gxrb_ratio - 1) + .sign (last_keypair.prv, last_keypair.pub) + .work (*system.work.generate (last_open_hash)) + .build (); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code); + auto open = builder + .open () + .source (send->hash ()) + .representative (last_keypair.pub) + .account (key.pub) + .sign (key.prv, key.pub) + .work (*system.work.generate (key.pub)) + .build (); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *open).code); + last_open_hash = open->hash (); last_keypair = key; } } @@ -1182,12 +1417,26 @@ 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::Gxrb_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 send = builder + .send () + .previous (latest_genesis) + .destination (key.pub) + .balance (nano::Gxrb_ratio - 1) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (latest_genesis)) + .build (); + auto open = builder + .open () + .source (send->hash ()) + .representative (nano::dev::genesis_key.pub) + .account (key.pub) + .sign (key.prv, key.pub) + .work (*system.work.generate (key.pub)) + .build (); { auto transaction = node->store.tx_begin_write (); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, open).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *open).code); } transaction.refresh (); node->active.prioritize_frontiers_for_confirmation (transaction, std::chrono::seconds (60), std::chrono::seconds (60)); @@ -1195,12 +1444,25 @@ 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::Gxrb_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 send1 = builder + .send () + .previous (send->hash ()) + .destination (key.pub) + .balance (nano::Gxrb_ratio - 2) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (send->hash ())) + .build (); + auto receive = builder + .receive () + .previous (open->hash ()) + .source (send1->hash ()) + .sign (key.prv, key.pub) + .work (*system.work.generate (open->hash ())) + .build (); { auto transaction = node->store.tx_begin_write (); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send1).code); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, receive).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send1).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *receive).code); } // Confirm that it gets replaced @@ -1373,18 +1635,47 @@ TEST (telemetry, under_load) system.wallet (0)->insert_adhoc (key.prv); 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::dev::constants.genesis_amount - num_blocks, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest_genesis))); + nano::block_builder builder; + auto send = builder + .state () + .account (nano::dev::genesis_key.pub) + .previous (latest_genesis) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - num_blocks) + .link (key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (latest_genesis)) + .build_shared (); 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))); + auto open = builder + .state () + .account (key.pub) + .previous (0) + .representative (key.pub) + .balance (num_blocks) + .link (send->hash ()) + .sign (key.prv, key.pub) + .work (*system.work.generate (key.pub)) + .build_shared (); node->process_active (open); auto latest_key = open->hash (); auto thread_func = [key1, &system, node, num_blocks] (nano::keypair const & keypair, nano::block_hash const & latest, nano::uint128_t const initial_amount) { auto latest_l = latest; + nano::block_builder builder; for (int i = 0; i < num_blocks; ++i) { - auto send (std::make_shared (keypair.pub, latest_l, keypair.pub, initial_amount - i - 1, key1.pub, keypair.prv, keypair.pub, *system.work.generate (latest_l))); + auto send = builder + .state () + .account (keypair.pub) + .previous (latest_l) + .representative (keypair.pub) + .balance (initial_amount - i - 1) + .link (key1.pub) + .sign (keypair.prv, keypair.pub) + .work (*system.work.generate (latest_l)) + .build_shared (); latest_l = send->hash (); node->process_active (send); } @@ -1519,11 +1810,21 @@ TEST (telemetry, many_nodes) // Give all nodes a non-default number of blocks nano::keypair key; - nano::state_block send (nano::dev::genesis_key.pub, nano::dev::genesis->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - nano::Mxrb_ratio, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (nano::dev::genesis->hash ())); + nano::block_builder builder; + auto send = builder + .state () + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::Mxrb_ratio) + .link (key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) + .build (); for (auto node : system.nodes) { auto transaction (node->store.tx_begin_write ()); - ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send).code); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code); } // This is the node which will request metrics from all other nodes @@ -1596,6 +1897,7 @@ TEST (signature_checker, mass_boundary_checks) add_boundary (nano::signature_checker::batch_size * i); } + nano::block_builder builder; for (auto num_threads = 0; num_threads < 5; ++num_threads) { nano::signature_checker checker (num_threads); @@ -1611,7 +1913,16 @@ TEST (signature_checker, mass_boundary_checks) std::vector signatures; signatures.reserve (max_size); nano::keypair key; - nano::state_block block (key.pub, 0, key.pub, 0, 0, key.prv, key.pub, 0); + auto block = builder + .state () + .account (key.pub) + .previous (0) + .representative (key.pub) + .balance (0) + .link (0) + .sign (key.prv, key.pub) + .work (0) + .build (); size_t last_size = 0; for (auto size : sizes) @@ -1623,11 +1934,11 @@ TEST (signature_checker, mass_boundary_checks) verifications.resize (size); for (auto i (0); i < extra_size; ++i) { - hashes.push_back (block.hash ()); + hashes.push_back (block->hash ()); messages.push_back (hashes.back ().bytes.data ()); lengths.push_back (sizeof (decltype (hashes)::value_type)); - pub_keys.push_back (block.hashables.account.bytes.data ()); - signatures.push_back (block.signature.bytes.data ()); + pub_keys.push_back (block->hashables.account.bytes.data ()); + signatures.push_back (block->signature.bytes.data ()); } nano::signature_check_set check = { size, messages.data (), lengths.data (), pub_keys.data (), signatures.data (), verifications.data () }; checker.verify (check); @@ -1892,6 +2203,7 @@ TEST (node, wallet_create_block_confirm_conflicts) for (int i = 0; i < 5; ++i) { nano::system system; + nano::block_builder builder; 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); @@ -1904,9 +2216,16 @@ TEST (node, wallet_create_block_confirm_conflicts) auto transaction = node->store.tx_begin_write (); for (auto i = num_blocks - 1; i > 0; --i) { - nano::send_block send (latest, key1.pub, nano::dev::constants.genesis_amount - nano::Gxrb_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 (); + auto send = builder + .send () + .previous (latest) + .destination (key1.pub) + .balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio + i + 1) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (latest)) + .build (); + ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code); + latest = send->hash (); } } From 288baeb6fef233d17ea133190343bdb15805ed9d Mon Sep 17 00:00:00 2001 From: clemahieu Date: Fri, 8 Jul 2022 20:53:48 +0100 Subject: [PATCH 32/34] Adds a ledger_context class and ledger_empty function which can be used by unit tests to easily create an empty ledger. This removes a lot of boilerplate code in associated tests. (#3848) --- nano/core_test/ledger.cpp | 1299 +++++++++++++------------------ nano/test_common/CMakeLists.txt | 2 + nano/test_common/ledger.cpp | 30 + nano/test_common/ledger.hpp | 33 + 4 files changed, 589 insertions(+), 775 deletions(-) create mode 100644 nano/test_common/ledger.cpp create mode 100644 nano/test_common/ledger.hpp diff --git a/nano/core_test/ledger.cpp b/nano/core_test/ledger.cpp index c6fd32dfc5..6a744622c4 100644 --- a/nano/core_test/ledger.cpp +++ b/nano/core_test/ledger.cpp @@ -3,6 +3,7 @@ #include #include #include +#include #include #include @@ -18,23 +19,17 @@ TEST (ledger, store_error) // Don't test this in rocksdb mode return; } - nano::logger_mt logger; - nano::lmdb::store store (logger, boost::filesystem::path ("///"), nano::dev::constants); - ASSERT_TRUE (store.init_error ()); - nano::stat stats; - nano::ledger ledger (store, stats, nano::dev::constants); + auto ctx = nano::test::context::ledger_empty (); } // 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 (), nano::dev::constants); - ASSERT_TRUE (!store->init_error ()); - nano::stat stats; - nano::ledger ledger (*store, stats, nano::dev::constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); + auto transaction = store.tx_begin_read (); nano::account account; - auto transaction (store->tx_begin_read ()); auto balance (ledger.account_balance (transaction, account)); ASSERT_TRUE (balance.is_zero ()); } @@ -42,38 +37,32 @@ TEST (ledger, empty) // Genesis account should have the max balance on empty initialization TEST (ledger, genesis_balance) { - nano::logger_mt logger; - 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::dev::constants); - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); - auto balance (ledger.account_balance (transaction, nano::dev::genesis->account ())); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); + auto transaction = store.tx_begin_write (); + 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 ())); + 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::dev::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::dev::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, nano::dev::genesis->hash ()); } TEST (ledger, process_modifies_sideband) { - nano::logger_mt logger; - 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::dev::constants); - store->initialize (store->tx_begin_write (), ledger.cache, ledger.constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::block_builder builder; auto send1 = builder @@ -86,23 +75,20 @@ TEST (ledger, process_modifies_sideband) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - 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 (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); } // Create a send block and publish it. TEST (ledger, process_send) { - nano::logger_mt logger; - 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::dev::constants); - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); + auto transaction = store.tx_begin_write (); 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::block_builder builder; auto send = builder @@ -113,26 +99,26 @@ TEST (ledger, process_send) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (info1.head)) .build (); - nano::block_hash hash1 (send->hash ()); - ASSERT_EQ (nano::dev::genesis_key.pub, store->frontier.get (transaction, info1.head)); + nano::block_hash hash1 = send->hash (); + 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)); + auto return1 = ledger.process (transaction, *send); ASSERT_EQ (nano::dev::genesis_key.pub, send->sideband ().account); ASSERT_EQ (2, send->sideband ().height); 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_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 (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_receivable (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 ())); + auto latest7 = dynamic_cast (latest6.get ()); ASSERT_NE (nullptr, latest7); ASSERT_EQ (*send, *latest7); // Create an open block opening an account accepting the send we just created @@ -146,36 +132,36 @@ TEST (ledger, process_send) .build (); nano::block_hash hash2 (open->hash ()); // This was a valid block, it should progress. - auto return2 (ledger.process (transaction, *open)); + auto return2 = ledger.process (transaction, *open); ASSERT_EQ (nano::process_result::progress, return2.code); ASSERT_EQ (key2.pub, open->sideband ().account); ASSERT_EQ (nano::dev::constants.genesis_amount - 50, open->sideband ().balance.number ()); ASSERT_EQ (1, open->sideband ().height); 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 (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 (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_receivable (transaction, 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 ())); + 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 ())); + 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)); nano::pending_info pending1; @@ -192,8 +178,8 @@ TEST (ledger, process_send) ASSERT_EQ (hash1, info6.head); ASSERT_FALSE (ledger.rollback (transaction, info6.head)); 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 ()); + 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_EQ (1, info7.block_count); @@ -202,21 +188,18 @@ TEST (ledger, process_send) 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_receivable (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 (), nano::dev::constants); - ASSERT_TRUE (!store->init_error ()); - nano::stat stats; - nano::ledger ledger (*store, stats, nano::dev::constants); - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); + auto transaction = store.tx_begin_write (); 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::block_builder builder; auto send = builder @@ -239,9 +222,9 @@ TEST (ledger, process_receive) .work (*pool.generate (key2.pub)) .build (); nano::block_hash hash2 (open->hash ()); - auto return1 (ledger.process (transaction, *open)); + 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::dev::constants.genesis_amount - 50, open->sideband ().balance.number ()); ASSERT_EQ (1, open->sideband ().height); @@ -255,7 +238,7 @@ TEST (ledger, process_receive) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (hash1)) .build (); - nano::block_hash hash3 (send2->hash ()); + nano::block_hash hash3 = send2->hash (); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send2).code); auto receive = builder .receive () @@ -264,26 +247,26 @@ TEST (ledger, process_receive) .sign (key2.prv, key2.pub) .work (*pool.generate (hash2)) .build (); - auto hash4 (receive->hash ()); - ASSERT_EQ (key2.pub, store->frontier.get (transaction, hash2)); - auto return2 (ledger.process (transaction, *receive)); + auto hash4 = receive->hash (); + 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::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 (0, ledger.account_receivable (transaction, key2.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_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_receivable (transaction, key2.pub)); ASSERT_EQ (nano::dev::constants.genesis_amount - 50, ledger.account_balance (transaction, key2.pub)); @@ -293,21 +276,18 @@ TEST (ledger, process_receive) 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 (), nano::dev::constants); - ASSERT_TRUE (!store->init_error ()); - nano::stat stats; - nano::ledger ledger (*store, stats, nano::dev::constants); - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); + auto transaction = store.tx_begin_write (); 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::block_builder builder; auto send = builder @@ -344,21 +324,18 @@ TEST (ledger, rollback_receiver) 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 (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 (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 (), nano::dev::constants); - ASSERT_TRUE (!store->init_error ()); - nano::stat stats; - nano::ledger ledger (*store, stats, nano::dev::constants); - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); + auto transaction = store.tx_begin_write (); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key5; nano::block_builder builder; @@ -419,11 +396,11 @@ TEST (ledger, rollback_representation) ASSERT_EQ (1, ledger.weight (key3.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::dev::constants.genesis_amount - 50, ledger.weight (key4.pub)); @@ -433,11 +410,11 @@ TEST (ledger, rollback_representation) ledger.rollback (transaction, send1->hash ()); 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::dev::constants.genesis_amount, ledger.weight (key5.pub)); ASSERT_EQ (0, ledger.weight (key3.pub)); @@ -445,13 +422,10 @@ TEST (ledger, rollback_representation) TEST (ledger, receive_rollback) { - nano::logger_mt logger; - 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::dev::constants); - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); + auto transaction = store.tx_begin_write (); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::block_builder builder; auto send = builder @@ -476,16 +450,13 @@ TEST (ledger, receive_rollback) TEST (ledger, process_duplicate) { - nano::logger_mt logger; - 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::dev::constants); - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); + auto transaction = store.tx_begin_write (); 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::block_builder builder; auto send = builder @@ -513,45 +484,34 @@ TEST (ledger, process_duplicate) TEST (ledger, representative_genesis) { - nano::logger_mt logger; - 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::dev::constants); - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); - auto latest (ledger.latest (transaction, nano::dev::genesis_key.pub)); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); + auto transaction = store.tx_begin_write (); + auto latest = ledger.latest (transaction, nano::dev::genesis_key.pub); ASSERT_FALSE (latest.is_zero ()); 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 (), nano::dev::constants); - ASSERT_TRUE (!store->init_error ()); - nano::stat stats; - nano::ledger ledger (*store, stats, nano::dev::constants); - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); 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 (), nano::dev::constants); - ASSERT_TRUE (!store->init_error ()); - nano::stat stats; - nano::ledger ledger (*store, stats, nano::dev::constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); + auto transaction = store.tx_begin_write (); nano::keypair key2; - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); 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)); + ASSERT_FALSE (store.account.get (transaction, nano::dev::genesis_key.pub, info1)); nano::block_builder builder; auto block = builder .change () @@ -560,23 +520,23 @@ TEST (ledger, representative_change) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (info1.head)) .build (); - 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)); 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 (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::dev::constants.genesis_amount, ledger.weight (nano::dev::genesis_key.pub)); ASSERT_EQ (0, ledger.weight (key2.pub)); @@ -584,18 +544,15 @@ TEST (ledger, representative_change) TEST (ledger, send_fork) { - nano::logger_mt logger; - 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::dev::constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); nano::keypair key2; nano::keypair key3; - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); + auto transaction = store.tx_begin_write (); 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::block_builder builder; auto block = builder .send () @@ -619,18 +576,15 @@ TEST (ledger, send_fork) TEST (ledger, receive_fork) { - nano::logger_mt logger; - 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::dev::constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); nano::keypair key2; nano::keypair key3; - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); + auto transaction = store.tx_begin_write (); 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::block_builder builder; auto block = builder .send () @@ -679,18 +633,15 @@ TEST (ledger, receive_fork) TEST (ledger, open_fork) { - nano::logger_mt logger; - 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::dev::constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); nano::keypair key2; nano::keypair key3; - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); + auto transaction = store.tx_begin_write (); 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::block_builder builder; auto block = builder .send () @@ -734,14 +685,11 @@ TEST (ledger, representation_changes) TEST (ledger, representation) { - nano::logger_mt logger; - 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::dev::constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); auto & rep_weights = ledger.cache.rep_weights; - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); + auto transaction = store.tx_begin_write (); 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; @@ -910,13 +858,10 @@ TEST (ledger, double_open) TEST (ledger, double_receive) { - nano::logger_mt logger; - 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::dev::constants); - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); + auto transaction = store.tx_begin_write (); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key2; nano::block_builder builder; @@ -1255,13 +1200,10 @@ TEST (ledger, successor) TEST (ledger, fail_change_old) { - nano::logger_mt logger; - 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::dev::constants); - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); + auto transaction = store.tx_begin_write (); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; nano::block_builder builder; @@ -1272,21 +1214,18 @@ TEST (ledger, fail_change_old) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - auto result1 (ledger.process (transaction, *block)); + auto result1 = ledger.process (transaction, *block); ASSERT_EQ (nano::process_result::progress, result1.code); - auto result2 (ledger.process (transaction, *block)); + auto result2 = ledger.process (transaction, *block); ASSERT_EQ (nano::process_result::old, result2.code); } TEST (ledger, fail_change_gap_previous) { - nano::logger_mt logger; - 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::dev::constants); - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); + auto transaction = store.tx_begin_write (); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; nano::block_builder builder; @@ -1297,19 +1236,16 @@ TEST (ledger, fail_change_gap_previous) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::root (1))) .build (); - auto result1 (ledger.process (transaction, *block)); + auto result1 = ledger.process (transaction, *block); ASSERT_EQ (nano::process_result::gap_previous, result1.code); } TEST (ledger, fail_change_bad_signature) { - nano::logger_mt logger; - 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::dev::constants); - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); + auto transaction = store.tx_begin_write (); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; nano::block_builder builder; @@ -1320,19 +1256,16 @@ TEST (ledger, fail_change_bad_signature) .sign (nano::keypair ().prv, 0) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - auto result1 (ledger.process (transaction, *block)); + auto result1 = ledger.process (transaction, *block); ASSERT_EQ (nano::process_result::bad_signature, result1.code); } TEST (ledger, fail_change_fork) { - nano::logger_mt logger; - 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::dev::constants); - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); + auto transaction = store.tx_begin_write (); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; nano::block_builder builder; @@ -1343,7 +1276,7 @@ TEST (ledger, fail_change_fork) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - auto result1 (ledger.process (transaction, *block1)); + auto result1 = ledger.process (transaction, *block1); ASSERT_EQ (nano::process_result::progress, result1.code); nano::keypair key2; auto block2 = builder @@ -1353,19 +1286,16 @@ TEST (ledger, fail_change_fork) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - auto result2 (ledger.process (transaction, *block2)); + auto result2 = ledger.process (transaction, *block2); ASSERT_EQ (nano::process_result::fork, result2.code); } TEST (ledger, fail_send_old) { - nano::logger_mt logger; - 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::dev::constants); - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); + auto transaction = store.tx_begin_write (); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; nano::block_builder builder; @@ -1377,21 +1307,18 @@ TEST (ledger, fail_send_old) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - auto result1 (ledger.process (transaction, *block)); + auto result1 = ledger.process (transaction, *block); ASSERT_EQ (nano::process_result::progress, result1.code); - auto result2 (ledger.process (transaction, *block)); + auto result2 = ledger.process (transaction, *block); ASSERT_EQ (nano::process_result::old, result2.code); } TEST (ledger, fail_send_gap_previous) { - nano::logger_mt logger; - 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::dev::constants); - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); + auto transaction = store.tx_begin_write (); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; nano::block_builder builder; @@ -1403,19 +1330,16 @@ TEST (ledger, fail_send_gap_previous) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::root (1))) .build (); - auto result1 (ledger.process (transaction, *block)); + auto result1 = ledger.process (transaction, *block); ASSERT_EQ (nano::process_result::gap_previous, result1.code); } TEST (ledger, fail_send_bad_signature) { - nano::logger_mt logger; - 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::dev::constants); - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); + auto transaction = store.tx_begin_write (); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; nano::block_builder builder; @@ -1427,19 +1351,16 @@ TEST (ledger, fail_send_bad_signature) .sign (nano::keypair ().prv, 0) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - auto result1 (ledger.process (transaction, *block)); + auto result1 = ledger.process (transaction, *block); ASSERT_EQ (nano::process_result::bad_signature, result1.code); } TEST (ledger, fail_send_negative_spend) { - nano::logger_mt logger; - 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::dev::constants); - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); + auto transaction = store.tx_begin_write (); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; nano::block_builder builder; @@ -1466,13 +1387,10 @@ TEST (ledger, fail_send_negative_spend) TEST (ledger, fail_send_fork) { - nano::logger_mt logger; - 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::dev::constants); - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); + auto transaction = store.tx_begin_write (); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; nano::block_builder builder; @@ -1499,13 +1417,10 @@ TEST (ledger, fail_send_fork) TEST (ledger, fail_open_old) { - nano::logger_mt logger; - 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::dev::constants); - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); + auto transaction = store.tx_begin_write (); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; nano::block_builder builder; @@ -1532,13 +1447,10 @@ TEST (ledger, fail_open_old) TEST (ledger, fail_open_gap_source) { - nano::logger_mt logger; - 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::dev::constants); - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); + auto transaction = store.tx_begin_write (); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; nano::block_builder builder; @@ -1550,19 +1462,16 @@ TEST (ledger, fail_open_gap_source) .sign (key1.prv, key1.pub) .work (*pool.generate (key1.pub)) .build (); - auto result2 (ledger.process (transaction, *block2)); + auto result2 = ledger.process (transaction, *block2); ASSERT_EQ (nano::process_result::gap_source, result2.code); } TEST (ledger, fail_open_bad_signature) { - nano::logger_mt logger; - 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::dev::constants); - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); + auto transaction = store.tx_begin_write (); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; nano::block_builder builder; @@ -1589,13 +1498,10 @@ 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 (), nano::dev::constants); - ASSERT_FALSE (store->init_error ()); - nano::stat stats; - nano::ledger ledger (*store, stats, nano::dev::constants); - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); + auto transaction = store.tx_begin_write (); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; nano::block_builder builder; @@ -1635,18 +1541,15 @@ TEST (ledger, fail_open_fork_previous) .work (*pool.generate (key1.pub)) .build (); 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 (), nano::dev::constants); - ASSERT_FALSE (store->init_error ()); - nano::stat stats; - nano::ledger ledger (*store, stats, nano::dev::constants); - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); + auto transaction = store.tx_begin_write (); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; nano::block_builder builder; @@ -1669,18 +1572,15 @@ TEST (ledger, fail_open_account_mismatch) .work (*pool.generate (badkey.pub)) .build (); 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 (), nano::dev::constants); - ASSERT_FALSE (store->init_error ()); - nano::stat stats; - nano::ledger ledger (*store, stats, nano::dev::constants); - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); + auto transaction = store.tx_begin_write (); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; nano::block_builder builder; @@ -1724,13 +1624,10 @@ TEST (ledger, fail_receive_old) TEST (ledger, fail_receive_gap_source) { - nano::logger_mt logger; - 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::dev::constants); - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); + auto transaction = store.tx_begin_write (); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; nano::block_builder builder; @@ -1742,7 +1639,7 @@ TEST (ledger, fail_receive_gap_source) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - auto result1 (ledger.process (transaction, *block1)); + auto result1 = ledger.process (transaction, *block1); ASSERT_EQ (nano::process_result::progress, result1.code); auto block2 = builder .send () @@ -1752,7 +1649,7 @@ TEST (ledger, fail_receive_gap_source) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (block1->hash ())) .build (); - auto result2 (ledger.process (transaction, *block2)); + auto result2 = ledger.process (transaction, *block2); ASSERT_EQ (nano::process_result::progress, result2.code); auto block3 = builder .open () @@ -1762,7 +1659,7 @@ TEST (ledger, fail_receive_gap_source) .sign (key1.prv, key1.pub) .work (*pool.generate (key1.pub)) .build (); - auto result3 (ledger.process (transaction, *block3)); + auto result3 = ledger.process (transaction, *block3); ASSERT_EQ (nano::process_result::progress, result3.code); auto block4 = builder .receive () @@ -1771,19 +1668,16 @@ TEST (ledger, fail_receive_gap_source) .sign (key1.prv, key1.pub) .work (*pool.generate (block3->hash ())) .build (); - auto result4 (ledger.process (transaction, *block4)); + auto result4 = ledger.process (transaction, *block4); ASSERT_EQ (nano::process_result::gap_source, result4.code); } TEST (ledger, fail_receive_overreceive) { - nano::logger_mt logger; - 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::dev::constants); - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); + auto transaction = store.tx_begin_write (); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; nano::block_builder builder; @@ -1795,7 +1689,7 @@ TEST (ledger, fail_receive_overreceive) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - auto result1 (ledger.process (transaction, *block1)); + auto result1 = ledger.process (transaction, *block1); ASSERT_EQ (nano::process_result::progress, result1.code); auto block2 = builder .open () @@ -1805,7 +1699,7 @@ TEST (ledger, fail_receive_overreceive) .sign (key1.prv, key1.pub) .work (*pool.generate (key1.pub)) .build (); - auto result3 (ledger.process (transaction, *block2)); + auto result3 = ledger.process (transaction, *block2); ASSERT_EQ (nano::process_result::progress, result3.code); auto block3 = builder .receive () @@ -1814,19 +1708,16 @@ TEST (ledger, fail_receive_overreceive) .sign (key1.prv, key1.pub) .work (*pool.generate (block2->hash ())) .build (); - auto result4 (ledger.process (transaction, *block3)); + auto result4 = ledger.process (transaction, *block3); ASSERT_EQ (nano::process_result::unreceivable, result4.code); } TEST (ledger, fail_receive_bad_signature) { - nano::logger_mt logger; - 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::dev::constants); - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); + auto transaction = store.tx_begin_write (); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; nano::block_builder builder; @@ -1838,7 +1729,7 @@ TEST (ledger, fail_receive_bad_signature) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - auto result1 (ledger.process (transaction, *block1)); + auto result1 = ledger.process (transaction, *block1); ASSERT_EQ (nano::process_result::progress, result1.code); auto block2 = builder .send () @@ -1848,7 +1739,7 @@ TEST (ledger, fail_receive_bad_signature) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (block1->hash ())) .build (); - auto result2 (ledger.process (transaction, *block2)); + auto result2 = ledger.process (transaction, *block2); ASSERT_EQ (nano::process_result::progress, result2.code); auto block3 = builder .open () @@ -1858,7 +1749,7 @@ TEST (ledger, fail_receive_bad_signature) .sign (key1.prv, key1.pub) .work (*pool.generate (key1.pub)) .build (); - auto result3 (ledger.process (transaction, *block3)); + auto result3 = ledger.process (transaction, *block3); ASSERT_EQ (nano::process_result::progress, result3.code); auto block4 = builder .receive () @@ -1867,19 +1758,16 @@ TEST (ledger, fail_receive_bad_signature) .sign (nano::keypair ().prv, 0) .work (*pool.generate (block3->hash ())) .build (); - auto result4 (ledger.process (transaction, *block4)); + auto result4 = ledger.process (transaction, *block4); ASSERT_EQ (nano::process_result::bad_signature, result4.code); } TEST (ledger, fail_receive_gap_previous_opened) { - nano::logger_mt logger; - 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::dev::constants); - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); + auto transaction = store.tx_begin_write (); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; nano::block_builder builder; @@ -1891,7 +1779,7 @@ TEST (ledger, fail_receive_gap_previous_opened) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - auto result1 (ledger.process (transaction, *block1)); + auto result1 = ledger.process (transaction, *block1); ASSERT_EQ (nano::process_result::progress, result1.code); auto block2 = builder .send () @@ -1901,7 +1789,7 @@ TEST (ledger, fail_receive_gap_previous_opened) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (block1->hash ())) .build (); - auto result2 (ledger.process (transaction, *block2)); + auto result2 = ledger.process (transaction, *block2); ASSERT_EQ (nano::process_result::progress, result2.code); auto block3 = builder .open () @@ -1911,7 +1799,7 @@ TEST (ledger, fail_receive_gap_previous_opened) .sign (key1.prv, key1.pub) .work (*pool.generate (key1.pub)) .build (); - auto result3 (ledger.process (transaction, *block3)); + auto result3 = ledger.process (transaction, *block3); ASSERT_EQ (nano::process_result::progress, result3.code); auto block4 = builder .receive () @@ -1920,19 +1808,16 @@ TEST (ledger, fail_receive_gap_previous_opened) .sign (key1.prv, key1.pub) .work (*pool.generate (nano::root (1))) .build (); - auto result4 (ledger.process (transaction, *block4)); + auto result4 = ledger.process (transaction, *block4); ASSERT_EQ (nano::process_result::gap_previous, result4.code); } TEST (ledger, fail_receive_gap_previous_unopened) { - nano::logger_mt logger; - 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::dev::constants); - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); + auto transaction = store.tx_begin_write (); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; nano::block_builder builder; @@ -1944,7 +1829,7 @@ TEST (ledger, fail_receive_gap_previous_unopened) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - auto result1 (ledger.process (transaction, *block1)); + auto result1 = ledger.process (transaction, *block1); ASSERT_EQ (nano::process_result::progress, result1.code); auto block2 = builder .send () @@ -1954,7 +1839,7 @@ TEST (ledger, fail_receive_gap_previous_unopened) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (block1->hash ())) .build (); - auto result2 (ledger.process (transaction, *block2)); + auto result2 = ledger.process (transaction, *block2); ASSERT_EQ (nano::process_result::progress, result2.code); auto block3 = builder .receive () @@ -1963,19 +1848,16 @@ TEST (ledger, fail_receive_gap_previous_unopened) .sign (key1.prv, key1.pub) .work (*pool.generate (nano::root (1))) .build (); - auto result3 (ledger.process (transaction, *block3)); + auto result3 = ledger.process (transaction, *block3); ASSERT_EQ (nano::process_result::gap_previous, result3.code); } TEST (ledger, fail_receive_fork_previous) { - nano::logger_mt logger; - 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::dev::constants); - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); + auto transaction = store.tx_begin_write (); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; nano::block_builder builder; @@ -1987,7 +1869,7 @@ TEST (ledger, fail_receive_fork_previous) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - auto result1 (ledger.process (transaction, *block1)); + auto result1 = ledger.process (transaction, *block1); ASSERT_EQ (nano::process_result::progress, result1.code); auto block2 = builder .send () @@ -1997,7 +1879,7 @@ TEST (ledger, fail_receive_fork_previous) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (block1->hash ())) .build (); - auto result2 (ledger.process (transaction, *block2)); + auto result2 = ledger.process (transaction, *block2); ASSERT_EQ (nano::process_result::progress, result2.code); auto block3 = builder .open () @@ -2007,7 +1889,7 @@ TEST (ledger, fail_receive_fork_previous) .sign (key1.prv, key1.pub) .work (*pool.generate (key1.pub)) .build (); - auto result3 (ledger.process (transaction, *block3)); + auto result3 = ledger.process (transaction, *block3); ASSERT_EQ (nano::process_result::progress, result3.code); nano::keypair key2; auto block4 = builder @@ -2018,7 +1900,7 @@ TEST (ledger, fail_receive_fork_previous) .sign (key1.prv, key1.pub) .work (*pool.generate (block3->hash ())) .build (); - auto result4 (ledger.process (transaction, *block4)); + auto result4 = ledger.process (transaction, *block4); ASSERT_EQ (nano::process_result::progress, result4.code); auto block5 = builder .receive () @@ -2027,19 +1909,16 @@ TEST (ledger, fail_receive_fork_previous) .sign (key1.prv, key1.pub) .work (*pool.generate (block3->hash ())) .build (); - auto result5 (ledger.process (transaction, *block5)); + auto result5 = ledger.process (transaction, *block5); ASSERT_EQ (nano::process_result::fork, result5.code); } TEST (ledger, fail_receive_received_source) { - nano::logger_mt logger; - 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::dev::constants); - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); + auto transaction = store.tx_begin_write (); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; nano::block_builder builder; @@ -2051,7 +1930,7 @@ TEST (ledger, fail_receive_received_source) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - auto result1 (ledger.process (transaction, *block1)); + auto result1 = ledger.process (transaction, *block1); ASSERT_EQ (nano::process_result::progress, result1.code); auto block2 = builder .send () @@ -2061,7 +1940,7 @@ TEST (ledger, fail_receive_received_source) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (block1->hash ())) .build (); - auto result2 (ledger.process (transaction, *block2)); + auto result2 = ledger.process (transaction, *block2); ASSERT_EQ (nano::process_result::progress, result2.code); auto block6 = builder .send () @@ -2071,7 +1950,7 @@ TEST (ledger, fail_receive_received_source) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (block2->hash ())) .build (); - auto result6 (ledger.process (transaction, *block6)); + auto result6 = ledger.process (transaction, *block6); ASSERT_EQ (nano::process_result::progress, result6.code); auto block3 = builder .open () @@ -2081,7 +1960,7 @@ TEST (ledger, fail_receive_received_source) .sign (key1.prv, key1.pub) .work (*pool.generate (key1.pub)) .build (); - auto result3 (ledger.process (transaction, *block3)); + auto result3 = ledger.process (transaction, *block3); ASSERT_EQ (nano::process_result::progress, result3.code); nano::keypair key2; auto block4 = builder @@ -2092,7 +1971,7 @@ TEST (ledger, fail_receive_received_source) .sign (key1.prv, key1.pub) .work (*pool.generate (block3->hash ())) .build (); - auto result4 (ledger.process (transaction, *block4)); + auto result4 = ledger.process (transaction, *block4); ASSERT_EQ (nano::process_result::progress, result4.code); auto block5 = builder .receive () @@ -2101,7 +1980,7 @@ TEST (ledger, fail_receive_received_source) .sign (key1.prv, key1.pub) .work (*pool.generate (block4->hash ())) .build (); - auto result5 (ledger.process (transaction, *block5)); + auto result5 = ledger.process (transaction, *block5); ASSERT_EQ (nano::process_result::progress, result5.code); auto block7 = builder .receive () @@ -2110,36 +1989,31 @@ TEST (ledger, fail_receive_received_source) .sign (key1.prv, key1.pub) .work (*pool.generate (block3->hash ())) .build (); - auto result7 (ledger.process (transaction, *block7)); + auto result7 = ledger.process (transaction, *block7); ASSERT_EQ (nano::process_result::fork, result7.code); } TEST (ledger, latest_empty) { - nano::logger_mt logger; - 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::dev::constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); nano::keypair key; - auto transaction (store->tx_begin_read ()); - auto latest (ledger.latest (transaction, key.pub)); + auto transaction = store.tx_begin_read (); + auto latest = ledger.latest (transaction, key.pub); ASSERT_TRUE (latest.is_zero ()); } TEST (ledger, latest_root) { - nano::logger_mt logger; - 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::dev::constants); - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); + auto transaction = store.tx_begin_write (); 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)); + auto hash1 = ledger.latest (transaction, nano::dev::genesis_key.pub); nano::block_builder builder; auto send = builder .send () @@ -2155,14 +2029,11 @@ TEST (ledger, latest_root) TEST (ledger, change_representative_move_representation) { - nano::logger_mt logger; - 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::dev::constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); nano::keypair key1; - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); + auto transaction = store.tx_begin_write (); 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::block_builder builder; @@ -2200,16 +2071,13 @@ TEST (ledger, change_representative_move_representation) TEST (ledger, send_open_receive_rollback) { - nano::logger_mt logger; - 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::dev::constants); - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); + auto transaction = store.tx_begin_write (); 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::block_builder builder; auto send1 = builder @@ -2220,7 +2088,7 @@ TEST (ledger, send_open_receive_rollback) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (info1.head)) .build (); - auto return1 (ledger.process (transaction, *send1)); + auto return1 = ledger.process (transaction, *send1); ASSERT_EQ (nano::process_result::progress, return1.code); auto send2 = builder .send () @@ -2230,7 +2098,7 @@ TEST (ledger, send_open_receive_rollback) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - auto return2 (ledger.process (transaction, *send2)); + auto return2 = ledger.process (transaction, *send2); ASSERT_EQ (nano::process_result::progress, return2.code); nano::keypair key2; auto open = builder @@ -2241,7 +2109,7 @@ TEST (ledger, send_open_receive_rollback) .sign (key1.prv, key1.pub) .work (*pool.generate (key1.pub)) .build (); - auto return4 (ledger.process (transaction, *open)); + auto return4 = ledger.process (transaction, *open); ASSERT_EQ (nano::process_result::progress, return4.code); auto receive = builder .receive () @@ -2250,7 +2118,7 @@ TEST (ledger, send_open_receive_rollback) .sign (key1.prv, key1.pub) .work (*pool.generate (open->hash ())) .build (); - auto return5 (ledger.process (transaction, *receive)); + auto return5 = ledger.process (transaction, *receive); ASSERT_EQ (nano::process_result::progress, return5.code); nano::keypair key3; ASSERT_EQ (100, ledger.weight (key2.pub)); @@ -2263,7 +2131,7 @@ TEST (ledger, send_open_receive_rollback) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send2->hash ())) .build (); - auto return6 (ledger.process (transaction, *change1)); + 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)); @@ -2292,18 +2160,15 @@ TEST (ledger, send_open_receive_rollback) TEST (ledger, bootstrap_rep_weight) { - nano::logger_mt logger; - 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::dev::constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); nano::account_info info1; nano::keypair key2; nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; { - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); - ASSERT_FALSE (store->account.get (transaction, nano::dev::genesis_key.pub, info1)); + auto transaction = store.tx_begin_write (); + ASSERT_FALSE (store.account.get (transaction, nano::dev::genesis_key.pub, info1)); nano::block_builder builder; auto send = builder .send () @@ -2322,8 +2187,8 @@ TEST (ledger, bootstrap_rep_weight) ASSERT_EQ (1000, ledger.weight (key2.pub)); } { - auto transaction (store->tx_begin_write ()); - ASSERT_FALSE (store->account.get (transaction, nano::dev::genesis_key.pub, info1)); + auto transaction = store.tx_begin_write (); + ASSERT_FALSE (store.account.get (transaction, nano::dev::genesis_key.pub, info1)); nano::block_builder builder; auto send = builder .send () @@ -2336,21 +2201,15 @@ TEST (ledger, bootstrap_rep_weight) ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send).code); } ASSERT_EQ (3, ledger.cache.block_count); - { - auto transaction (store->tx_begin_read ()); - ASSERT_EQ (0, ledger.weight (key2.pub)); - } + ASSERT_EQ (0, ledger.weight (key2.pub)); } TEST (ledger, block_destination_source) { - nano::logger_mt logger; - 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::dev::constants); - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); + auto transaction = store.tx_begin_write (); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair dest; nano::uint128_t balance (nano::dev::constants.genesis_amount); @@ -2437,13 +2296,10 @@ TEST (ledger, block_destination_source) TEST (ledger, state_account) { - nano::logger_mt logger; - 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::dev::constants); - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); + auto transaction = store.tx_begin_write (); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::block_builder builder; auto send1 = builder @@ -2462,13 +2318,10 @@ TEST (ledger, state_account) TEST (ledger, state_send_receive) { - nano::logger_mt logger; - 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::dev::constants); - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); + auto transaction = store.tx_begin_write (); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::block_builder builder; auto send1 = builder @@ -2482,14 +2335,14 @@ TEST (ledger, state_send_receive) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); 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::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.balance (transaction, send1->hash ())); ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, send1->hash ())); ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::dev::genesis->account ())); - ASSERT_TRUE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send1->hash ()))); + 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); @@ -2505,15 +2358,15 @@ TEST (ledger, state_send_receive) .work (*pool.generate (send1->hash ())) .build (); 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::dev::constants.genesis_amount, ledger.balance (transaction, receive1->hash ())); ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, receive1->hash ())); 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_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); @@ -2522,13 +2375,10 @@ TEST (ledger, state_send_receive) TEST (ledger, state_receive) { - nano::logger_mt logger; - 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::dev::constants); - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); + auto transaction = store.tx_begin_write (); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::block_builder builder; auto send1 = builder @@ -2540,8 +2390,8 @@ TEST (ledger, state_receive) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); 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::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.balance (transaction, send1->hash ())); @@ -2558,8 +2408,8 @@ TEST (ledger, state_receive) .work (*pool.generate (send1->hash ())) .build (); 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::dev::constants.genesis_amount, ledger.balance (transaction, receive1->hash ())); @@ -2572,14 +2422,11 @@ TEST (ledger, state_receive) } TEST (ledger, state_rep_change) -{ - nano::logger_mt logger; - 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::dev::constants); - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); +{ + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); + auto transaction = store.tx_begin_write (); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair rep; nano::block_builder builder; @@ -2594,8 +2441,8 @@ TEST (ledger, state_rep_change) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); 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::dev::constants.genesis_amount, ledger.balance (transaction, change1->hash ())); @@ -2610,13 +2457,10 @@ TEST (ledger, state_rep_change) TEST (ledger, state_open) { - nano::logger_mt logger; - 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::dev::constants); - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); + auto transaction = store.tx_begin_write (); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair destination; nano::block_builder builder; @@ -2631,14 +2475,14 @@ TEST (ledger, state_open) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); 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::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.balance (transaction, send1->hash ())); ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, send1->hash ())); ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::dev::genesis->account ())); - ASSERT_TRUE (store->pending.exists (transaction, nano::pending_key (destination.pub, send1->hash ()))); + ASSERT_TRUE (store.pending.exists (transaction, nano::pending_key (destination.pub, send1->hash ()))); auto open1 = builder .state () .account (destination.pub) @@ -2650,15 +2494,15 @@ TEST (ledger, state_open) .work (*pool.generate (destination.pub)) .build (); 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::Gxrb_ratio, ledger.balance (transaction, open1->hash ())); ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, open1->hash ())); 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 (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); @@ -2668,13 +2512,10 @@ TEST (ledger, state_open) // Make sure old block types can't be inserted after a state block. TEST (ledger, send_after_state_fail) { - nano::logger_mt logger; - 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::dev::constants); - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); + auto transaction = store.tx_begin_write (); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::block_builder builder; auto send1 = builder @@ -2702,13 +2543,10 @@ TEST (ledger, send_after_state_fail) // Make sure old block types can't be inserted after a state block. TEST (ledger, receive_after_state_fail) { - nano::logger_mt logger; - 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::dev::constants); - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); + auto transaction = store.tx_begin_write (); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::block_builder builder; auto send1 = builder @@ -2735,13 +2573,10 @@ TEST (ledger, receive_after_state_fail) // Make sure old block types can't be inserted after a state block. TEST (ledger, change_after_state_fail) { - nano::logger_mt logger; - 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::dev::constants); - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); + auto transaction = store.tx_begin_write (); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::block_builder builder; auto send1 = builder @@ -2768,13 +2603,10 @@ TEST (ledger, change_after_state_fail) TEST (ledger, state_unreceivable_fail) { - nano::logger_mt logger; - 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::dev::constants); - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); + auto transaction = store.tx_begin_write (); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::block_builder builder; auto send1 = builder @@ -2786,8 +2618,8 @@ TEST (ledger, state_unreceivable_fail) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); 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::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.balance (transaction, send1->hash ())); @@ -2808,13 +2640,10 @@ TEST (ledger, state_unreceivable_fail) TEST (ledger, state_receive_bad_amount_fail) { - nano::logger_mt logger; - 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::dev::constants); - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); + auto transaction = store.tx_begin_write (); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::block_builder builder; auto send1 = builder @@ -2826,8 +2655,8 @@ TEST (ledger, state_receive_bad_amount_fail) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); 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::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.balance (transaction, send1->hash ())); @@ -2848,13 +2677,10 @@ TEST (ledger, state_receive_bad_amount_fail) TEST (ledger, state_no_link_amount_fail) { - nano::logger_mt logger; - 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::dev::constants); - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); + auto transaction = store.tx_begin_write (); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::block_builder builder; auto send1 = builder @@ -2884,13 +2710,10 @@ TEST (ledger, state_no_link_amount_fail) TEST (ledger, state_receive_wrong_account_fail) { - nano::logger_mt logger; - 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::dev::constants); - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); + auto transaction = store.tx_begin_write (); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::block_builder builder; auto send1 = builder @@ -2904,8 +2727,8 @@ TEST (ledger, state_receive_wrong_account_fail) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); 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::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.balance (transaction, send1->hash ())); @@ -2927,13 +2750,10 @@ TEST (ledger, state_receive_wrong_account_fail) TEST (ledger, state_open_state_fork) { - nano::logger_mt logger; - 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::dev::constants); - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); + auto transaction = store.tx_begin_write (); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair destination; nano::block_builder builder; @@ -2973,13 +2793,10 @@ 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 (), nano::dev::constants); - ASSERT_TRUE (!store->init_error ()); - nano::stat stats; - nano::ledger ledger (*store, stats, nano::dev::constants); - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); + auto transaction = store.tx_begin_write (); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair destination; nano::block_builder builder; @@ -3015,18 +2832,15 @@ TEST (ledger, state_state_open_fork) .build (); 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 (), nano::dev::constants); - ASSERT_TRUE (!store->init_error ()); - nano::stat stats; - nano::ledger ledger (*store, stats, nano::dev::constants); - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); + auto transaction = store.tx_begin_write (); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair destination; nano::block_builder builder; @@ -3056,13 +2870,10 @@ TEST (ledger, state_open_previous_fail) TEST (ledger, state_open_source_fail) { - nano::logger_mt logger; - 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::dev::constants); - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); + auto transaction = store.tx_begin_write (); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair destination; nano::block_builder builder; @@ -3092,13 +2903,10 @@ TEST (ledger, state_open_source_fail) TEST (ledger, state_send_change) { - nano::logger_mt logger; - 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::dev::constants); - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); + auto transaction = store.tx_begin_write (); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair rep; nano::block_builder builder; @@ -3113,8 +2921,8 @@ TEST (ledger, state_send_change) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); 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::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.balance (transaction, send1->hash ())); @@ -3129,13 +2937,10 @@ TEST (ledger, state_send_change) TEST (ledger, state_receive_change) { - nano::logger_mt logger; - 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::dev::constants); - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); + auto transaction = store.tx_begin_write (); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::block_builder builder; auto send1 = builder @@ -3149,8 +2954,8 @@ TEST (ledger, state_receive_change) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); 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::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.balance (transaction, send1->hash ())); @@ -3168,8 +2973,8 @@ TEST (ledger, state_receive_change) .work (*pool.generate (send1->hash ())) .build (); 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::dev::constants.genesis_amount, ledger.balance (transaction, receive1->hash ())); @@ -3184,13 +2989,10 @@ TEST (ledger, state_receive_change) TEST (ledger, state_open_old) { - nano::logger_mt logger; - 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::dev::constants); - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); + auto transaction = store.tx_begin_write (); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair destination; nano::block_builder builder; @@ -3221,13 +3023,10 @@ TEST (ledger, state_open_old) TEST (ledger, state_receive_old) { - nano::logger_mt logger; - 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::dev::constants); - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); + auto transaction = store.tx_begin_write (); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair destination; nano::block_builder builder; @@ -3277,13 +3076,10 @@ TEST (ledger, state_receive_old) TEST (ledger, state_rollback_send) { - nano::logger_mt logger; - 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::dev::constants); - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); + auto transaction = store.tx_begin_write (); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::block_builder builder; auto send1 = builder @@ -3297,34 +3093,31 @@ TEST (ledger, state_rollback_send) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); 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::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.account_balance (transaction, nano::dev::genesis->account ())); ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::dev::genesis->account ())); nano::pending_info info; - ASSERT_FALSE (store->pending.get (transaction, nano::pending_key (nano::dev::genesis->account (), send1->hash ()), info)); + 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::Gxrb_ratio, info.amount.number ()); ASSERT_FALSE (ledger.rollback (transaction, send1->hash ())); - ASSERT_FALSE (store->block.exists (transaction, send1->hash ())); + 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); + 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 (), nano::dev::constants); - ASSERT_TRUE (!store->init_error ()); - nano::stat stats; - nano::ledger ledger (*store, stats, nano::dev::constants); - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); + auto transaction = store.tx_begin_write (); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::block_builder builder; auto send1 = builder @@ -3349,27 +3142,24 @@ TEST (ledger, state_rollback_receive) .work (*pool.generate (send1->hash ())) .build (); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *receive1).code); - ASSERT_FALSE (store->pending.exists (transaction, nano::pending_key (nano::dev::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::dev::genesis->account (), send1->hash ()), info)); + 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::Gxrb_ratio, info.amount.number ()); - ASSERT_FALSE (store->block.exists (transaction, receive1->hash ())); + ASSERT_FALSE (store.block.exists (transaction, receive1->hash ())); ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.account_balance (transaction, nano::dev::genesis->account ())); ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::dev::genesis->account ())); - ASSERT_EQ (store->account.count (transaction), ledger.cache.account_count); + 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 (), nano::dev::constants); - ASSERT_TRUE (!store->init_error ()); - nano::stat stats; - nano::ledger ledger (*store, stats, nano::dev::constants); - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); + auto transaction = store.tx_begin_write (); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key; nano::block_builder builder; @@ -3395,27 +3185,24 @@ TEST (ledger, state_rollback_received_send) .work (*pool.generate (key.pub)) .build (); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *receive1).code); - ASSERT_FALSE (store->pending.exists (transaction, nano::pending_key (nano::dev::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::dev::genesis->account (), send1->hash ()))); - ASSERT_FALSE (store->block.exists (transaction, send1->hash ())); - ASSERT_FALSE (store->block.exists (transaction, receive1->hash ())); + 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 (), nano::dev::constants); - ASSERT_TRUE (!store->init_error ()); - nano::stat stats; - nano::ledger ledger (*store, stats, nano::dev::constants); - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); + auto transaction = store.tx_begin_write (); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair rep; nano::block_builder builder; @@ -3431,7 +3218,7 @@ TEST (ledger, state_rep_change_rollback) .build (); 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_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)); @@ -3439,13 +3226,10 @@ TEST (ledger, state_rep_change_rollback) TEST (ledger, state_open_rollback) { - nano::logger_mt logger; - 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::dev::constants); - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); + auto transaction = store.tx_begin_write (); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair destination; nano::block_builder builder; @@ -3472,25 +3256,22 @@ TEST (ledger, state_open_rollback) .build (); 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::dev::constants.genesis_amount - nano::Gxrb_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_FALSE (store.pending.get (transaction, nano::pending_key (destination.pub, send1->hash ()), info)); ASSERT_EQ (nano::dev::genesis->account (), info.source); ASSERT_EQ (nano::Gxrb_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 (), nano::dev::constants); - ASSERT_TRUE (!store->init_error ()); - nano::stat stats; - nano::ledger ledger (*store, stats, nano::dev::constants); - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); + auto transaction = store.tx_begin_write (); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair rep; nano::block_builder builder; @@ -3506,22 +3287,19 @@ TEST (ledger, state_send_change_rollback) .build (); 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_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 (), nano::dev::constants); - ASSERT_TRUE (!store->init_error ()); - nano::stat stats; - nano::ledger ledger (*store, stats, nano::dev::constants); - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); + auto transaction = store.tx_begin_write (); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::block_builder builder; auto send1 = builder @@ -3548,22 +3326,19 @@ TEST (ledger, state_receive_change_rollback) .build (); 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_FALSE (store.block.exists (transaction, receive1->hash ())); ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.account_balance (transaction, nano::dev::genesis->account ())); ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_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 (), nano::dev::constants); - ASSERT_TRUE (!store->init_error ()); - nano::stat stats; - nano::ledger ledger (*store, stats, nano::dev::constants); - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); + auto transaction = store.tx_begin_write (); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair destination; nano::block_builder builder; @@ -3701,13 +3476,10 @@ 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 (), nano::dev::constants); - ASSERT_TRUE (!store->init_error ()); - nano::stat stats; - nano::ledger ledger (*store, stats, nano::dev::constants); - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); + auto transaction = store.tx_begin_write (); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair destination; nano::block_builder builder; @@ -3867,13 +3639,10 @@ TEST (ledger, epoch_blocks_v2_general) TEST (ledger, epoch_blocks_receive_upgrade) { - nano::logger_mt logger; - 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::dev::constants); - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); + auto transaction = store.tx_begin_write (); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair destination; nano::block_builder builder; @@ -4069,18 +3838,15 @@ TEST (ledger, epoch_blocks_receive_upgrade) 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 (), nano::dev::constants); - ASSERT_TRUE (!store->init_error ()); - nano::stat stats; - nano::ledger ledger (*store, stats, nano::dev::constants); - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); + auto transaction = store.tx_begin_write (); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair destination; nano::block_builder builder; @@ -4754,16 +4520,13 @@ TEST (ledger, unchecked_receive) TEST (ledger, confirmation_height_not_updated) { - nano::logger_mt logger; - 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::dev::constants); - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); + auto transaction = store.tx_begin_write (); 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::block_builder builder; auto send1 = builder @@ -4775,11 +4538,11 @@ TEST (ledger, confirmation_height_not_updated) .work (*pool.generate (account_info.head)) .build (); nano::confirmation_height_info confirmation_height_info; - ASSERT_FALSE (store->confirmation_height.get (transaction, nano::dev::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 (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::dev::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 (nano::dev::genesis->hash (), confirmation_height_info.frontier); auto open1 = builder @@ -4791,7 +4554,7 @@ TEST (ledger, confirmation_height_not_updated) .work (*pool.generate (key.pub)) .build (); 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); } @@ -4830,12 +4593,9 @@ TEST (ledger, zero_rep) TEST (ledger, work_validation) { - nano::logger_mt logger; - 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::dev::constants); - store->initialize (store->tx_begin_write (), ledger.cache, ledger.constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::block_builder builder; auto gen = nano::dev::genesis_key; @@ -4849,9 +4609,9 @@ TEST (ledger, work_validation) { block_a.block_work_set (block_a.block_work () + 1); } - EXPECT_EQ (nano::process_result::insufficient_work, ledger.process (store->tx_begin_write (), block_a).code); + EXPECT_EQ (nano::process_result::insufficient_work, ledger.process (store.tx_begin_write (), block_a).code); block_a.block_work_set (*pool.generate (block_a.root (), threshold)); - EXPECT_EQ (nano::process_result::progress, ledger.process (store->tx_begin_write (), block_a).code); + EXPECT_EQ (nano::process_result::progress, ledger.process (store.tx_begin_write (), block_a).code); }; std::error_code ec; @@ -4922,14 +4682,11 @@ TEST (ledger, work_validation) TEST (ledger, dependents_confirmed) { + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); + auto transaction = store.tx_begin_write (); nano::block_builder builder; - nano::logger_mt logger; - 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::dev::constants); - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); 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; @@ -4994,7 +4751,6 @@ TEST (ledger, dependents_confirmed) TEST (ledger, dependents_confirmed_pruning) { - nano::block_builder builder; nano::logger_mt logger; auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_FALSE (store->init_error ()); @@ -5003,6 +4759,7 @@ TEST (ledger, dependents_confirmed_pruning) ledger.pruning = true; auto transaction (store->tx_begin_write ()); store->initialize (transaction, ledger.cache, ledger.constants); + nano::block_builder builder; nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; auto send1 = builder.state () @@ -5045,14 +4802,11 @@ TEST (ledger, dependents_confirmed_pruning) TEST (ledger, block_confirmed) { + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); + auto transaction = store.tx_begin_write (); nano::block_builder builder; - nano::logger_mt logger; - 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::dev::constants); - auto transaction (store->tx_begin_write ()); - store->initialize (transaction, ledger.cache, ledger.constants); 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; @@ -5078,12 +4832,10 @@ TEST (ledger, block_confirmed) TEST (ledger, cache) { - nano::logger_mt logger; - 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::dev::constants); - store->initialize (store->tx_begin_write (), ledger.cache, ledger.constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); + auto & stats = ctx.stats (); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::block_builder builder; @@ -5107,7 +4859,7 @@ TEST (ledger, cache) }; nano::keypair key; - auto const latest = ledger.latest (store->tx_begin_read (), nano::dev::genesis->account ()); + auto const latest = ledger.latest (store.tx_begin_read (), nano::dev::genesis->account ()); auto send = builder.state () .account (nano::dev::genesis->account ()) .previous (latest) @@ -5127,27 +4879,27 @@ TEST (ledger, cache) .work (*pool.generate (key.pub)) .build (); { - auto transaction (store->tx_begin_write ()); + auto transaction (store.tx_begin_write ()); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send).code); } ++block_count; --genesis_weight; cache_check (ledger.cache); - cache_check (nano::ledger (*store, stats, nano::dev::constants).cache); + cache_check (nano::ledger (store, stats, nano::dev::constants).cache); { - auto transaction (store->tx_begin_write ()); + auto transaction (store.tx_begin_write ()); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *open).code); } ++block_count; ++account_count; cache_check (ledger.cache); - cache_check (nano::ledger (*store, stats, nano::dev::constants).cache); + cache_check (nano::ledger (store, stats, nano::dev::constants).cache); { - auto transaction (store->tx_begin_write ()); + auto transaction (store.tx_begin_write ()); nano::confirmation_height_info height; ASSERT_FALSE (ledger.store.confirmation_height.get (transaction, nano::dev::genesis->account (), height)); ++height.height; @@ -5159,10 +4911,10 @@ TEST (ledger, cache) ++cemented_count; cache_check (ledger.cache); - cache_check (nano::ledger (*store, stats, nano::dev::constants).cache); + cache_check (nano::ledger (store, stats, nano::dev::constants).cache); { - auto transaction (store->tx_begin_write ()); + auto transaction (store.tx_begin_write ()); nano::confirmation_height_info height; ledger.store.confirmation_height.get (transaction, key.pub, height); height.height += 1; @@ -5174,16 +4926,16 @@ TEST (ledger, cache) ++cemented_count; cache_check (ledger.cache); - cache_check (nano::ledger (*store, stats, nano::dev::constants).cache); + cache_check (nano::ledger (store, stats, nano::dev::constants).cache); { - auto transaction (store->tx_begin_write ()); + auto transaction (store.tx_begin_write ()); ledger.store.pruned.put (transaction, open->hash ()); ++ledger.cache.pruned_count; } ++pruned_count; cache_check (ledger.cache); - cache_check (nano::ledger (*store, stats, nano::dev::constants).cache); + cache_check (nano::ledger (store, stats, nano::dev::constants).cache); } } @@ -5862,12 +5614,9 @@ TEST (ledger, migrate_lmdb_to_rocksdb) TEST (ledger, unconfirmed_frontiers) { - nano::logger_mt logger; - 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::dev::constants); - store->initialize (store->tx_begin_write (), ledger.cache, ledger.constants); + auto ctx = nano::test::context::ledger_empty (); + auto & ledger = ctx.ledger (); + auto & store = ctx.store (); nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; auto unconfirmed_frontiers = ledger.unconfirmed_frontiers (); @@ -5875,7 +5624,7 @@ TEST (ledger, unconfirmed_frontiers) nano::state_block_builder builder; nano::keypair key; - auto const latest = ledger.latest (store->tx_begin_read (), nano::dev::genesis->account ()); + auto const latest = ledger.latest (store.tx_begin_read (), nano::dev::genesis->account ()); auto send = builder.make_block () .account (nano::dev::genesis->account ()) .previous (latest) @@ -5886,7 +5635,7 @@ TEST (ledger, unconfirmed_frontiers) .work (*pool.generate (latest)) .build (); - ASSERT_EQ (nano::process_result::progress, ledger.process (store->tx_begin_write (), *send).code); + ASSERT_EQ (nano::process_result::progress, ledger.process (store.tx_begin_write (), *send).code); unconfirmed_frontiers = ledger.unconfirmed_frontiers (); ASSERT_EQ (unconfirmed_frontiers.size (), 1); diff --git a/nano/test_common/CMakeLists.txt b/nano/test_common/CMakeLists.txt index 1e70b41704..2f9cb474ae 100644 --- a/nano/test_common/CMakeLists.txt +++ b/nano/test_common/CMakeLists.txt @@ -1,5 +1,7 @@ add_library( test_common + ledger.hpp + ledger.cpp network.hpp network.cpp system.hpp diff --git a/nano/test_common/ledger.cpp b/nano/test_common/ledger.cpp new file mode 100644 index 0000000000..3189375ad5 --- /dev/null +++ b/nano/test_common/ledger.cpp @@ -0,0 +1,30 @@ +#include +#include + +nano::test::context::ledger_context::ledger_context () : + store_m{ nano::make_store (logger, nano::unique_path (), nano::dev::constants) }, + ledger_m{ *store_m, stats_m, nano::dev::constants } +{ + debug_assert (!store_m->init_error ()); + store_m->initialize (store_m->tx_begin_write (), ledger_m.cache, ledger_m.constants); +} + +nano::ledger & nano::test::context::ledger_context::ledger () +{ + return ledger_m; +} + +nano::store & nano::test::context::ledger_context::store () +{ + return *store_m; +} + +nano::stat & nano::test::context::ledger_context::stats () +{ + return stats_m; +} + +auto nano::test::context::ledger_empty () -> ledger_context +{ + return ledger_context{}; +} diff --git a/nano/test_common/ledger.hpp b/nano/test_common/ledger.hpp new file mode 100644 index 0000000000..19ccf46882 --- /dev/null +++ b/nano/test_common/ledger.hpp @@ -0,0 +1,33 @@ +#pragma once + +#include +#include +#include +#include + +namespace nano +{ +class store; +namespace test +{ + namespace context + { + class ledger_context + { + public: + ledger_context (); + nano::ledger & ledger (); + nano::store & store (); + nano::stat & stats (); + + private: + nano::logger_mt logger; + std::unique_ptr store_m; + nano::stat stats_m; + nano::ledger ledger_m; + }; + + ledger_context ledger_empty (); + } +} +} From 5e0a46e6d3d9764342d0c66496af2f1e3f64b82b Mon Sep 17 00:00:00 2001 From: gr0vity Date: Sat, 9 Jul 2022 12:39:37 +0200 Subject: [PATCH 33/34] clang format --- nano/node/node.cpp | 2 +- nano/node/node_observers.hpp | 2 +- nano/node/websocket.cpp | 10 +++++----- nano/node/websocket.hpp | 2 +- 4 files changed, 8 insertions(+), 8 deletions(-) diff --git a/nano/node/node.cpp b/nano/node/node.cpp index 4badd3d2aa..ad0ebc0997 100644 --- a/nano/node/node.cpp +++ b/nano/node/node.cpp @@ -282,7 +282,7 @@ nano::node::node (boost::asio::io_context & io_ctx_a, boost::filesystem::path co } }); - observers.active_started.add ([this] (nano::block_hash const& hash_a) { + observers.active_started.add ([this] (nano::block_hash const & hash_a) { if (this->websocket_server->any_subscriber (nano::websocket::topic::started_election)) { nano::websocket::message_builder builder; diff --git a/nano/node/node_observers.hpp b/nano/node/node_observers.hpp index c3e95c8a92..3411b60a7d 100644 --- a/nano/node/node_observers.hpp +++ b/nano/node/node_observers.hpp @@ -15,7 +15,7 @@ class node_observers final blocks_t blocks; nano::observer_set wallet; nano::observer_set, std::shared_ptr, nano::vote_code> vote; - nano::observer_set active_started; + nano::observer_set active_started; nano::observer_set active_stopped; nano::observer_set account_balance; nano::observer_set> endpoint; diff --git a/nano/node/websocket.cpp b/nano/node/websocket.cpp index a569adb470..7489ba4632 100644 --- a/nano/node/websocket.cpp +++ b/nano/node/websocket.cpp @@ -697,14 +697,14 @@ void nano::websocket::listener::decrease_subscriber_count (nano::websocket::topi count -= 1; } -nano::websocket::message nano::websocket::message_builder::started_election(nano::block_hash const& hash_a) +nano::websocket::message nano::websocket::message_builder::started_election (nano::block_hash const & hash_a) { - nano::websocket::message message_l(nano::websocket::topic::started_election); - set_common_fields(message_l); + nano::websocket::message message_l (nano::websocket::topic::started_election); + set_common_fields (message_l); boost::property_tree::ptree message_node_l; - message_node_l.add("hash", hash_a.to_string()); - message_l.contents.add_child("message", message_node_l); + message_node_l.add ("hash", hash_a.to_string ()); + message_l.contents.add_child ("message", message_node_l); return message_l; } diff --git a/nano/node/websocket.hpp b/nano/node/websocket.hpp index dd72b67dd8..f4569e5c57 100644 --- a/nano/node/websocket.hpp +++ b/nano/node/websocket.hpp @@ -83,7 +83,7 @@ namespace websocket { public: message block_confirmed (std::shared_ptr const & block_a, nano::account const & account_a, nano::amount const & amount_a, std::string subtype, bool include_block, nano::election_status const & election_status_a, std::vector const & election_votes_a, nano::websocket::confirmation_options const & options_a); - message started_election (nano::block_hash const& hash_a); + message started_election (nano::block_hash const & hash_a); message stopped_election (nano::block_hash const & hash_a); message vote_received (std::shared_ptr const & vote_a, nano::vote_code code_a); message work_generation (nano::work_version const version_a, nano::block_hash const & root_a, uint64_t const work_a, uint64_t const difficulty_a, uint64_t const publish_threshold_a, std::chrono::milliseconds const & duration_a, std::string const & peer_a, std::vector const & bad_peers_a, bool const completed_a = true, bool const cancelled_a = false); From 34cbd37d0ebdb919bb8f1f1a6be92d7224c444bf Mon Sep 17 00:00:00 2001 From: gr0vity Date: Sat, 9 Jul 2022 13:52:17 +0200 Subject: [PATCH 34/34] use block_builder and standard initialisation syntax --- nano/core_test/websocket.cpp | 14 +++++++++++--- 1 file changed, 11 insertions(+), 3 deletions(-) diff --git a/nano/core_test/websocket.cpp b/nano/core_test/websocket.cpp index df2cf3cf9b..fa53de44b1 100644 --- a/nano/core_test/websocket.cpp +++ b/nano/core_test/websocket.cpp @@ -131,7 +131,7 @@ TEST (websocket, started_election) nano::node_config config (nano::get_available_port (), system.logging); config.websocket_config.enabled = true; config.websocket_config.port = nano::get_available_port (); - auto node1 (system.add_node (config)); + auto node1 = system.add_node (config); std::atomic ack_ready{ false }; auto task = ([&ack_ready, config, &node1] () { @@ -148,9 +148,17 @@ TEST (websocket, started_election) // Create election, causing a websocket message to be emitted nano::keypair key1; - 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::block_builder builder; + auto send1 = builder + .send () + .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 (nano::dev::genesis->hash ())) + .build_shared (); nano::publish publish1{ nano::dev::network_params.network, send1 }; - auto channel1 (node1->network.udp_channels.create (node1->network.endpoint ())); + auto channel1 = node1->network.udp_channels.create (node1->network.endpoint ()); node1->network.inbound (publish1, channel1); ASSERT_TIMELY (1s, node1->active.election (send1->qualified_root ())); ASSERT_TIMELY (5s, future.wait_for (0s) == std::future_status::ready);