From 2422230bc2e6086d32b1a77b0816561038aedcc1 Mon Sep 17 00:00:00 2001 From: Wesley Shillingford Date: Wed, 28 Aug 2019 13:04:58 +0100 Subject: [PATCH] Cache rep weights (#2217) * Cache rep weights * Review comments * Use rep_block not head * Remove left over code from testing * Review comments * Formatting * Actually use new flag in ledger weights caching --- nano/core_test/block_store.cpp | 432 ++++++++---------- nano/core_test/ledger.cpp | 628 ++++++++++++--------------- nano/core_test/network.cpp | 78 ++-- nano/core_test/node.cpp | 42 +- nano/core_test/processor_service.cpp | 14 +- nano/core_test/versioning.cpp | 30 +- nano/core_test/wallet.cpp | 19 +- nano/core_test/wallets.cpp | 8 +- nano/core_test/websocket.cpp | 21 +- nano/lib/CMakeLists.txt | 2 + nano/lib/rep_weights.cpp | 69 +++ nano/lib/rep_weights.hpp | 33 ++ nano/nano_node/daemon.cpp | 5 +- nano/nano_node/entry.cpp | 32 +- nano/nano_wallet/entry.cpp | 5 +- nano/node/cli.cpp | 12 +- nano/node/json_handler.cpp | 29 +- nano/node/lmdb/lmdb.cpp | 35 +- nano/node/lmdb/lmdb.hpp | 11 +- nano/node/node.cpp | 43 +- nano/node/node.hpp | 17 +- nano/node/nodeconfig.hpp | 2 + nano/node/online_reps.cpp | 4 +- nano/node/online_reps.hpp | 2 +- nano/node/rocksdb/rocksdb.cpp | 20 +- nano/node/rocksdb/rocksdb.hpp | 5 +- nano/node/testing.cpp | 5 +- nano/node/vote_processor.cpp | 5 +- nano/node/wallet.cpp | 12 +- nano/node/wallet.hpp | 5 +- nano/qt_test/qt.cpp | 7 +- nano/rpc_test/rpc.cpp | 6 +- nano/secure/blockstore.hpp | 14 +- nano/secure/blockstore_partial.hpp | 49 +-- nano/secure/ledger.cpp | 55 ++- nano/secure/ledger.hpp | 5 +- nano/slow_test/node.cpp | 12 +- 37 files changed, 841 insertions(+), 932 deletions(-) create mode 100644 nano/lib/rep_weights.cpp create mode 100644 nano/lib/rep_weights.hpp diff --git a/nano/core_test/block_store.cpp b/nano/core_test/block_store.cpp index 239772d1..979a0fc6 100644 --- a/nano/core_test/block_store.cpp +++ b/nano/core_test/block_store.cpp @@ -19,9 +19,8 @@ void modify_genesis_account_info_to_v5 (nano::mdb_store & store, nano::transacti TEST (block_store, construction) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); } TEST (block_store, sideband_serialization) @@ -52,9 +51,8 @@ TEST (block_store, sideband_serialization) TEST (block_store, add_item) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); nano::open_block block (0, 1, 0, nano::keypair ().prv, 0, 0); nano::uint256_union hash1 (block.hash ()); auto transaction (store->tx_begin_write ()); @@ -76,9 +74,8 @@ TEST (block_store, add_item) TEST (block_store, clear_successor) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); nano::open_block block1 (0, 1, 0, nano::keypair ().prv, 0, 0); auto transaction (store->tx_begin_write ()); nano::block_sideband sideband (nano::block_type::open, 0, 0, 0, 0, 0); @@ -99,9 +96,8 @@ TEST (block_store, clear_successor) TEST (block_store, add_nonempty_block) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); nano::keypair key1; nano::open_block block (0, 1, 0, nano::keypair ().prv, 0, 0); nano::uint256_union hash1 (block.hash ()); @@ -119,9 +115,8 @@ TEST (block_store, add_nonempty_block) TEST (block_store, add_two_items) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); nano::keypair key1; nano::open_block block (0, 1, 1, nano::keypair ().prv, 0, 0); nano::uint256_union hash1 (block.hash ()); @@ -151,9 +146,8 @@ TEST (block_store, add_two_items) TEST (block_store, add_receive) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); nano::keypair key1; nano::keypair key2; nano::open_block block1 (0, 1, 0, nano::keypair ().prv, 0, 0); @@ -174,9 +168,8 @@ TEST (block_store, add_receive) TEST (block_store, add_pending) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); nano::keypair key1; nano::pending_key key2 (0, 0); nano::pending_info pending1; @@ -193,9 +186,8 @@ TEST (block_store, add_pending) TEST (block_store, pending_iterator) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); auto transaction (store->tx_begin_write ()); ASSERT_EQ (store->pending_end (), store->pending_begin (transaction)); store->pending_put (transaction, nano::pending_key (1, 2), { 2, 3, nano::epoch::epoch_1 }); @@ -219,9 +211,8 @@ TEST (block_store, pending_iterator) TEST (block_store, pending_iterator_comparison) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); nano::stat stats; auto transaction (store->tx_begin_write ()); // Populate pending @@ -263,13 +254,13 @@ TEST (block_store, pending_iterator_comparison) TEST (block_store, genesis) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); nano::genesis genesis; auto hash (genesis.hash ()); + nano::rep_weights rep_weights; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, rep_weights); nano::account_info info; ASSERT_FALSE (store->account_get (transaction, nano::genesis_account, info)); ASSERT_EQ (hash, info.head); @@ -289,27 +280,11 @@ TEST (block_store, genesis) ASSERT_EQ (nano::genesis_account, nano::test_genesis_key.pub); } -TEST (representation, changes) -{ - nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); - nano::keypair key1; - auto transaction (store->tx_begin_write ()); - ASSERT_EQ (0, store->representation_get (transaction, key1.pub)); - store->representation_put (transaction, key1.pub, 1); - ASSERT_EQ (1, store->representation_get (transaction, key1.pub)); - store->representation_put (transaction, key1.pub, 2); - ASSERT_EQ (2, store->representation_get (transaction, key1.pub)); -} - TEST (bootstrap, simple) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); auto block1 (std::make_shared (0, 1, 2, nano::keypair ().prv, 4, 5)); auto transaction (store->tx_begin_write ()); auto block2 (store->unchecked_get (transaction, block1->previous ())); @@ -326,9 +301,8 @@ TEST (bootstrap, simple) TEST (unchecked, multiple) { nano::logger_mt logger; - bool init (false); - nano::mdb_store store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + nano::mdb_store store (logger, nano::unique_path ()); + ASSERT_TRUE (!store.init_error ()); auto block1 (std::make_shared (4, 1, 2, nano::keypair ().prv, 4, 5)); auto transaction (store.tx_begin_write ()); auto block2 (store.unchecked_get (transaction, block1->previous ())); @@ -344,9 +318,8 @@ TEST (unchecked, multiple) TEST (unchecked, double_put) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); auto block1 (std::make_shared (4, 1, 2, nano::keypair ().prv, 4, 5)); auto transaction (store->tx_begin_write ()); auto block2 (store->unchecked_get (transaction, block1->previous ())); @@ -360,9 +333,8 @@ TEST (unchecked, double_put) TEST (unchecked, multiple_get) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); auto block1 (std::make_shared (4, 1, 2, nano::keypair ().prv, 4, 5)); auto block2 (std::make_shared (3, 1, 2, nano::keypair ().prv, 4, 5)); auto block3 (std::make_shared (5, 1, 2, nano::keypair ().prv, 4, 5)); @@ -412,9 +384,8 @@ TEST (unchecked, multiple_get) TEST (block_store, empty_accounts) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); auto transaction (store->tx_begin_read ()); auto begin (store->latest_begin (transaction)); auto end (store->latest_end ()); @@ -424,9 +395,8 @@ TEST (block_store, empty_accounts) TEST (block_store, one_block) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); nano::open_block block1 (0, 1, 0, nano::keypair ().prv, 0, 0); auto transaction (store->tx_begin_write ()); nano::block_sideband sideband (nano::block_type::open, 0, 0, 0, 0, 0); @@ -437,9 +407,8 @@ TEST (block_store, one_block) TEST (block_store, empty_bootstrap) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); auto transaction (store->tx_begin_read ()); auto begin (store->unchecked_begin (transaction)); auto end (store->unchecked_end ()); @@ -449,9 +418,8 @@ TEST (block_store, empty_bootstrap) TEST (block_store, one_bootstrap) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); auto block1 (std::make_shared (0, 1, 2, nano::keypair ().prv, 4, 5)); auto transaction (store->tx_begin_write ()); store->unchecked_put (transaction, block1->hash (), block1); @@ -472,9 +440,8 @@ TEST (block_store, one_bootstrap) TEST (block_store, unchecked_begin_search) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + 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); @@ -483,9 +450,8 @@ TEST (block_store, unchecked_begin_search) TEST (block_store, frontier_retrieval) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); nano::account account1 (0); nano::account_info info1 (0, 0, 0, 0, 0, 0, nano::epoch::epoch_0); auto transaction (store->tx_begin_write ()); @@ -499,9 +465,8 @@ TEST (block_store, frontier_retrieval) TEST (block_store, one_account) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); nano::account account (0); nano::block_hash hash (0); auto transaction (store->tx_begin_write ()); @@ -526,9 +491,8 @@ TEST (block_store, one_account) TEST (block_store, two_block) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); nano::open_block block1 (0, 1, 1, nano::keypair ().prv, 0, 0); block1.hashables.account = 1; std::vector hashes; @@ -550,9 +514,8 @@ TEST (block_store, two_block) TEST (block_store, two_account) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); nano::account account1 (1); nano::block_hash hash1 (2); nano::account account2 (3); @@ -591,9 +554,8 @@ TEST (block_store, two_account) TEST (block_store, latest_find) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); nano::account account1 (1); nano::block_hash hash1 (2); nano::account account2 (3); @@ -618,9 +580,8 @@ TEST (block_store, latest_find) TEST (block_store, bad_path) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, boost::filesystem::path ("///")); - ASSERT_TRUE (init); + auto store = nano::make_store (logger, boost::filesystem::path ("///")); + ASSERT_TRUE (store->init_error ()); } #endif @@ -633,17 +594,15 @@ TEST (block_store, DISABLED_already_open) // File can be shared file.open (path.string ().c_str ()); ASSERT_TRUE (file.is_open ()); nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, path); - ASSERT_TRUE (init); + auto store = nano::make_store (logger, path); + ASSERT_TRUE (store->init_error ()); } TEST (block_store, roots) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + 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); @@ -657,9 +616,8 @@ TEST (block_store, roots) TEST (block_store, pending_exists) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); nano::pending_key two (2, 0); nano::pending_info pending; auto transaction (store->tx_begin_write ()); @@ -671,9 +629,8 @@ TEST (block_store, pending_exists) TEST (block_store, latest_exists) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); nano::block_hash two (2); nano::account_info info; auto transaction (store->tx_begin_write ()); @@ -686,9 +643,8 @@ TEST (block_store, latest_exists) TEST (block_store, large_iteration) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); std::unordered_set accounts1; for (auto i (0); i < 1000; ++i) { @@ -715,9 +671,8 @@ TEST (block_store, large_iteration) TEST (block_store, frontier) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); auto transaction (store->tx_begin_write ()); nano::block_hash hash (100); nano::account account (200); @@ -731,9 +686,8 @@ TEST (block_store, frontier) TEST (block_store, block_replace) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); nano::send_block send1 (0, 0, 0, nano::keypair ().prv, 0, 1); nano::send_block send2 (0, 0, 0, nano::keypair ().prv, 0, 2); auto transaction (store->tx_begin_write ()); @@ -749,9 +703,8 @@ TEST (block_store, block_replace) TEST (block_store, block_count) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); { auto transaction (store->tx_begin_write ()); ASSERT_EQ (0, store->block_count (transaction).sum ()); @@ -767,9 +720,8 @@ TEST (block_store, block_count) TEST (block_store, account_count) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); { auto transaction (store->tx_begin_write ()); ASSERT_EQ (0, store->account_count (transaction)); @@ -784,22 +736,21 @@ TEST (block_store, account_count) TEST (block_store, cemented_count) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); auto transaction (store->tx_begin_write ()); ASSERT_EQ (0, store->cemented_count (transaction)); nano::genesis genesis; - store->initialize (transaction, genesis); + nano::rep_weights rep_weights; + store->initialize (transaction, genesis, rep_weights); ASSERT_EQ (1, store->cemented_count (transaction)); } TEST (block_store, sequence_increment) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); nano::keypair key1; nano::keypair key2; auto block1 (std::make_shared (0, 1, 0, nano::keypair ().prv, 0, 0)); @@ -832,15 +783,14 @@ TEST (mdb_block_store, upgrade_v2_v3) auto path (nano::unique_path ()); { nano::logger_mt logger; - bool init (false); - nano::mdb_store store (init, logger, path); - ASSERT_TRUE (!init); + nano::mdb_store store (logger, path); + ASSERT_TRUE (!store.init_error ()); auto transaction (store.tx_begin_write ()); nano::genesis genesis; auto hash (genesis.hash ()); - store.initialize (transaction, genesis); nano::stat stats; nano::ledger ledger (store, stats); + store.initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); nano::change_block change (hash, key1.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (hash)); change_hash = change.hash (); @@ -848,10 +798,10 @@ TEST (mdb_block_store, upgrade_v2_v3) ASSERT_EQ (0, ledger.weight (transaction, nano::test_genesis_key.pub)); ASSERT_EQ (nano::genesis_amount, ledger.weight (transaction, key1.pub)); store.version_put (transaction, 2); - store.representation_put (transaction, key1.pub, 7); + ledger.rep_weights.representation_put (key1.pub, 7); ASSERT_EQ (7, ledger.weight (transaction, key1.pub)); ASSERT_EQ (2, store.version_get (transaction)); - store.representation_put (transaction, key2.pub, 6); + ledger.rep_weights.representation_put (key2.pub, 6); ASSERT_EQ (6, ledger.weight (transaction, key2.pub)); nano::account_info info; ASSERT_FALSE (store.account_get (transaction, nano::test_genesis_key.pub, info)); @@ -862,12 +812,11 @@ TEST (mdb_block_store, upgrade_v2_v3) assert (status == 0); } nano::logger_mt logger; - bool init (false); - nano::mdb_store store (init, logger, path); + nano::mdb_store store (logger, path); nano::stat stats; nano::ledger ledger (store, stats); auto transaction (store.tx_begin_write ()); - ASSERT_TRUE (!init); + ASSERT_TRUE (!store.init_error ()); ASSERT_LT (2, store.version_get (transaction)); ASSERT_EQ (nano::genesis_amount, ledger.weight (transaction, key1.pub)); ASSERT_EQ (0, ledger.weight (transaction, key2.pub)); @@ -884,9 +833,8 @@ TEST (mdb_block_store, upgrade_v3_v4) auto path (nano::unique_path ()); { nano::logger_mt logger; - bool init (false); - nano::mdb_store store (init, logger, path); - ASSERT_FALSE (init); + nano::mdb_store store (logger, path); + ASSERT_FALSE (store.init_error ()); auto transaction (store.tx_begin_write ()); store.version_put (transaction, 3); nano::pending_info_v3 info (key1.pub, 100, key2.pub); @@ -894,12 +842,11 @@ TEST (mdb_block_store, upgrade_v3_v4) ASSERT_EQ (0, status); } nano::logger_mt logger; - bool init (false); - nano::mdb_store store (init, logger, path); + nano::mdb_store store (logger, path); nano::stat stats; nano::ledger ledger (store, stats); auto transaction (store.tx_begin_write ()); - ASSERT_FALSE (init); + ASSERT_FALSE (store.init_error ()); ASSERT_LT (3, store.version_get (transaction)); nano::pending_key key (key2.pub, key3.pub); nano::pending_info info; @@ -917,14 +864,13 @@ TEST (mdb_block_store, upgrade_v4_v5) auto path (nano::unique_path ()); { nano::logger_mt logger; - bool init (false); - nano::mdb_store store (init, logger, path); - ASSERT_FALSE (init); + nano::mdb_store store (logger, path); + ASSERT_FALSE (store.init_error ()); auto transaction (store.tx_begin_write ()); nano::genesis genesis; nano::stat stats; nano::ledger ledger (store, stats); - store.initialize (transaction, genesis); + store.initialize (transaction, genesis, ledger.rep_weights); store.version_put (transaction, 4); nano::account_info info; ASSERT_FALSE (store.account_get (transaction, nano::test_genesis_key.pub, info)); @@ -940,9 +886,8 @@ TEST (mdb_block_store, upgrade_v4_v5) modify_genesis_account_info_to_v5 (store, transaction); } nano::logger_mt logger; - bool init (false); - nano::mdb_store store (init, logger, path); - ASSERT_FALSE (init); + nano::mdb_store store (logger, path); + ASSERT_FALSE (store.init_error ()); auto transaction (store.tx_begin_read ()); ASSERT_EQ (hash, store.block_successor (transaction, genesis_hash)); } @@ -950,13 +895,13 @@ TEST (mdb_block_store, upgrade_v4_v5) TEST (block_store, block_random) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); nano::genesis genesis; { + nano::rep_weights rep_weights; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, rep_weights); } auto transaction (store->tx_begin_read ()); auto block (store->block_random (transaction)); @@ -969,19 +914,18 @@ TEST (mdb_block_store, upgrade_v5_v6) auto path (nano::unique_path ()); { nano::logger_mt logger; - bool init (false); - nano::mdb_store store (init, logger, path); - ASSERT_FALSE (init); + nano::mdb_store store (logger, path); + ASSERT_FALSE (store.init_error ()); auto transaction (store.tx_begin_write ()); nano::genesis genesis; - store.initialize (transaction, genesis); + nano::rep_weights rep_weights; + store.initialize (transaction, genesis, rep_weights); store.version_put (transaction, 5); modify_genesis_account_info_to_v5 (store, transaction); } nano::logger_mt logger; - bool init (false); - nano::mdb_store store (init, logger, path); - ASSERT_FALSE (init); + nano::mdb_store store (logger, path); + ASSERT_FALSE (store.init_error ()); auto transaction (store.tx_begin_read ()); nano::account_info info; store.account_get (transaction, nano::test_genesis_key.pub, info); @@ -993,12 +937,12 @@ TEST (mdb_block_store, upgrade_v6_v7) auto path (nano::unique_path ()); { nano::logger_mt logger; - bool init (false); - nano::mdb_store store (init, logger, path); - ASSERT_FALSE (init); + nano::mdb_store store (logger, path); + ASSERT_FALSE (store.init_error ()); auto transaction (store.tx_begin_write ()); nano::genesis genesis; - store.initialize (transaction, genesis); + nano::rep_weights rep_weights; + store.initialize (transaction, genesis, rep_weights); store.version_put (transaction, 6); modify_account_info_to_v13 (store, transaction, nano::genesis_account); auto send1 (std::make_shared (0, 0, 0, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0)); @@ -1007,9 +951,8 @@ TEST (mdb_block_store, upgrade_v6_v7) ASSERT_NE (store.unchecked_end (), store.unchecked_begin (transaction)); } nano::logger_mt logger; - bool init (false); - nano::mdb_store store (init, logger, path); - ASSERT_FALSE (init); + nano::mdb_store store (logger, path); + ASSERT_FALSE (store.init_error ()); auto transaction (store.tx_begin_read ()); ASSERT_EQ (store.unchecked_end (), store.unchecked_begin (transaction)); } @@ -1019,8 +962,7 @@ TEST (block_store, DISABLED_change_dupsort) // Unchecked is no longer dupsort ta { auto path (nano::unique_path ()); nano::logger_mt logger; - bool init (false); - nano::mdb_store store (init, logger, path); + nano::mdb_store store (logger, path); auto transaction (store.tx_begin_write ()); ASSERT_EQ (0, mdb_drop (store.env.tx (transaction), store.unchecked, 1)); ASSERT_EQ (0, mdb_dbi_open (store.env.tx (transaction), "unchecked", MDB_CREATE, &store.unchecked)); @@ -1065,17 +1007,15 @@ TEST (mdb_block_store, upgrade_v7_v8) auto path (nano::unique_path ()); { nano::logger_mt logger; - bool init (false); - nano::mdb_store store (init, logger, path); + nano::mdb_store store (logger, path); auto transaction (store.tx_begin_write ()); ASSERT_EQ (0, mdb_drop (store.env.tx (transaction), store.unchecked, 1)); ASSERT_EQ (0, mdb_dbi_open (store.env.tx (transaction), "unchecked", MDB_CREATE, &store.unchecked)); store.version_put (transaction, 7); } nano::logger_mt logger; - bool init (false); - nano::mdb_store store (init, logger, path); - ASSERT_FALSE (init); + nano::mdb_store store (logger, path); + ASSERT_FALSE (store.init_error ()); auto transaction (store.tx_begin_write ()); auto send1 (std::make_shared (0, 0, 0, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0)); auto send2 (std::make_shared (1, 0, 0, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0)); @@ -1095,9 +1035,8 @@ TEST (block_store, sequence_flush) { auto path (nano::unique_path ()); nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, path); - ASSERT_FALSE (init); + auto store = nano::make_store (logger, path); + ASSERT_FALSE (store->init_error ()); auto transaction (store->tx_begin_write ()); nano::keypair key1; auto send1 (std::make_shared (0, 0, 0, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0)); @@ -1113,9 +1052,8 @@ TEST (block_store, sequence_flush_by_hash) { auto path (nano::unique_path ()); nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, path); - ASSERT_FALSE (init); + auto store = nano::make_store (logger, path); + ASSERT_FALSE (store->init_error ()); auto transaction (store->tx_begin_write ()); nano::keypair key1; std::vector blocks1; @@ -1137,8 +1075,7 @@ TEST (mdb_block_store, upgrade_v8_v9) nano::keypair key; { nano::logger_mt logger; - bool init (false); - nano::mdb_store store (init, logger, path); + nano::mdb_store store (logger, path); auto transaction (store.tx_begin_write ()); ASSERT_EQ (0, mdb_drop (store.env.tx (transaction), store.vote, 1)); ASSERT_EQ (0, mdb_dbi_open (store.env.tx (transaction), "sequence", MDB_CREATE, &store.vote)); @@ -1147,9 +1084,8 @@ TEST (mdb_block_store, upgrade_v8_v9) store.version_put (transaction, 8); } nano::logger_mt logger; - bool init (false); - nano::mdb_store store (init, logger, path); - ASSERT_FALSE (init); + nano::mdb_store store (logger, path); + ASSERT_FALSE (store.init_error ()); auto transaction (store.tx_begin_read ()); ASSERT_LT (8, store.version_get (transaction)); auto vote (store.vote_get (transaction, key.pub)); @@ -1160,15 +1096,15 @@ TEST (mdb_block_store, upgrade_v8_v9) TEST (block_store, state_block) { nano::logger_mt logger; - bool error (false); - auto store = nano::make_store (error, logger, nano::unique_path ()); - ASSERT_FALSE (error); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_FALSE (store->init_error ()); nano::genesis genesis; nano::keypair key1; nano::state_block block1 (1, genesis.hash (), 3, 4, 6, key1.prv, key1.pub, 7); { auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + nano::rep_weights rep_weights; + store->initialize (transaction, genesis, rep_weights); ASSERT_EQ (nano::block_type::state, block1.type ()); nano::block_sideband sideband1 (nano::block_type::state, 0, 0, 0, 0, 0); store->block_put (transaction, block1.hash (), block1, sideband1); @@ -1214,16 +1150,16 @@ void write_legacy_sideband (nano::mdb_store & store_a, nano::transaction & trans TEST (mdb_block_store, upgrade_sideband_genesis) { - bool error (false); nano::genesis genesis; auto path (nano::unique_path ()); { nano::logger_mt logger; - nano::mdb_store store (error, logger, path); - ASSERT_FALSE (error); + nano::mdb_store store (logger, path); + ASSERT_FALSE (store.init_error ()); auto transaction (store.tx_begin_write ()); store.version_put (transaction, 11); - store.initialize (transaction, genesis); + nano::rep_weights rep_weights; + store.initialize (transaction, genesis, rep_weights); modify_account_info_to_v13 (store, transaction, nano::genesis_account); nano::block_sideband sideband; auto genesis_block (store.block_get (transaction, genesis.hash (), &sideband)); @@ -1235,8 +1171,8 @@ TEST (mdb_block_store, upgrade_sideband_genesis) ASSERT_EQ (0, sideband.height); } nano::logger_mt logger; - nano::mdb_store store (error, logger, path); - ASSERT_FALSE (error); + nano::mdb_store store (logger, path); + ASSERT_FALSE (store.init_error ()); auto transaction (store.tx_begin_read ()); ASSERT_TRUE (store.full_sideband (transaction)); nano::block_sideband sideband; @@ -1247,19 +1183,18 @@ TEST (mdb_block_store, upgrade_sideband_genesis) TEST (mdb_block_store, upgrade_sideband_two_blocks) { - bool error (false); nano::genesis genesis; nano::block_hash hash2; auto path (nano::unique_path ()); { nano::logger_mt logger; - nano::mdb_store store (error, logger, path); - ASSERT_FALSE (error); + nano::mdb_store store (logger, path); + ASSERT_FALSE (store.init_error ()); nano::stat stat; nano::ledger ledger (store, stat); auto transaction (store.tx_begin_write ()); store.version_put (transaction, 11); - store.initialize (transaction, genesis); + store.initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); nano::state_block block (nano::test_genesis_key.pub, genesis.hash (), nano::test_genesis_key.pub, nano::genesis_amount - nano::Gxrb_ratio, nano::test_genesis_key.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ())); hash2 = block.hash (); @@ -1269,8 +1204,8 @@ TEST (mdb_block_store, upgrade_sideband_two_blocks) modify_account_info_to_v13 (store, transaction, nano::genesis_account); } nano::logger_mt logger; - nano::mdb_store store (error, logger, path); - ASSERT_FALSE (error); + nano::mdb_store store (logger, path); + ASSERT_FALSE (store.init_error ()); auto transaction (store.tx_begin_read ()); ASSERT_TRUE (store.full_sideband (transaction)); nano::block_sideband sideband; @@ -1285,7 +1220,6 @@ TEST (mdb_block_store, upgrade_sideband_two_blocks) TEST (mdb_block_store, upgrade_sideband_two_accounts) { - bool error (false); nano::genesis genesis; nano::block_hash hash2; nano::block_hash hash3; @@ -1293,13 +1227,12 @@ TEST (mdb_block_store, upgrade_sideband_two_accounts) auto path (nano::unique_path ()); { nano::logger_mt logger; - nano::mdb_store store (error, logger, path); - ASSERT_FALSE (error); + nano::mdb_store store (logger, path); nano::stat stat; nano::ledger ledger (store, stat); auto transaction (store.tx_begin_write ()); store.version_put (transaction, 11); - store.initialize (transaction, genesis); + store.initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); nano::state_block block1 (nano::test_genesis_key.pub, genesis.hash (), nano::test_genesis_key.pub, nano::genesis_amount - nano::Gxrb_ratio, key.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ())); hash2 = block1.hash (); @@ -1314,8 +1247,8 @@ TEST (mdb_block_store, upgrade_sideband_two_accounts) modify_account_info_to_v13 (store, transaction, block2.account ()); } nano::logger_mt logger; - nano::mdb_store store (error, logger, path); - ASSERT_FALSE (error); + nano::mdb_store store (logger, path); + ASSERT_FALSE (store.init_error ()); auto transaction (store.tx_begin_read ()); ASSERT_TRUE (store.full_sideband (transaction)); nano::block_sideband sideband; @@ -1335,15 +1268,14 @@ TEST (mdb_block_store, upgrade_sideband_two_accounts) TEST (mdb_block_store, insert_after_legacy) { nano::logger_mt logger; - bool error (false); nano::genesis genesis; - nano::mdb_store store (error, logger, nano::unique_path ()); - ASSERT_FALSE (error); + nano::mdb_store store (logger, nano::unique_path ()); + ASSERT_FALSE (store.init_error ()); nano::stat stat; nano::ledger ledger (store, stat); auto transaction (store.tx_begin_write ()); store.version_put (transaction, 11); - store.initialize (transaction, genesis); + store.initialize (transaction, genesis, ledger.rep_weights); write_legacy_sideband (store, transaction, *genesis.open, 0, store.open_blocks); nano::work_pool pool (std::numeric_limits::max ()); nano::state_block block (nano::test_genesis_key.pub, genesis.hash (), nano::test_genesis_key.pub, nano::genesis_amount - nano::Gxrb_ratio, nano::test_genesis_key.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ())); @@ -1354,14 +1286,13 @@ TEST (mdb_block_store, insert_after_legacy) TEST (mdb_block_store, legacy_account_computed) { nano::logger_mt logger; - bool init (false); - nano::mdb_store store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + nano::mdb_store store (logger, nano::unique_path ()); + ASSERT_TRUE (!store.init_error ()); nano::stat stats; nano::ledger ledger (store, stats); nano::genesis genesis; auto transaction (store.tx_begin_write ()); - store.initialize (transaction, genesis); + store.initialize (transaction, genesis, ledger.rep_weights); store.version_put (transaction, 11); write_legacy_sideband (store, transaction, *genesis.open, 0, store.open_blocks); ASSERT_EQ (nano::genesis_account, ledger.account (transaction, genesis.hash ())); @@ -1376,13 +1307,13 @@ TEST (mdb_block_store, upgrade_sideband_epoch) nano::work_pool pool (std::numeric_limits::max ()); { nano::logger_mt logger; - nano::mdb_store store (error, logger, path); + nano::mdb_store store (logger, path); ASSERT_FALSE (error); nano::stat stat; nano::ledger ledger (store, stat, 42, nano::test_genesis_key.pub); auto transaction (store.tx_begin_write ()); store.version_put (transaction, 11); - store.initialize (transaction, genesis); + store.initialize (transaction, genesis, ledger.rep_weights); nano::state_block block1 (nano::test_genesis_key.pub, genesis.hash (), nano::test_genesis_key.pub, nano::genesis_amount, 42, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ())); hash2 = block1.hash (); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block1).code); @@ -1392,7 +1323,7 @@ TEST (mdb_block_store, upgrade_sideband_epoch) modify_account_info_to_v13 (store, transaction, nano::genesis_account); } nano::logger_mt logger; - nano::mdb_store store (error, logger, path); + nano::mdb_store store (logger, path); nano::stat stat; nano::ledger ledger (store, stat, 42, nano::test_genesis_key.pub); ASSERT_FALSE (error); @@ -1410,19 +1341,18 @@ TEST (mdb_block_store, upgrade_sideband_epoch) TEST (mdb_block_store, sideband_height) { nano::logger_mt logger; - bool error (false); nano::genesis genesis; nano::keypair epoch_key; nano::keypair key1; nano::keypair key2; nano::keypair key3; - nano::mdb_store store (error, logger, nano::unique_path ()); - ASSERT_FALSE (error); + nano::mdb_store store (logger, nano::unique_path ()); + ASSERT_FALSE (store.init_error ()); nano::stat stat; nano::ledger ledger (store, stat); ledger.epoch_signer = epoch_key.pub; auto transaction (store.tx_begin_write ()); - store.initialize (transaction, genesis); + store.initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); nano::send_block send (genesis.hash (), nano::test_genesis_key.pub, nano::genesis_amount - nano::Gxrb_ratio, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send).code); @@ -1490,8 +1420,8 @@ TEST (block_store, peers) { nano::logger_mt logger; auto init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); nano::endpoint_key endpoint (boost::asio::ip::address_v6::any ().to_bytes (), 100); { @@ -1588,9 +1518,8 @@ TEST (block_store, endpoint_key_byte_order) TEST (block_store, online_weight) { nano::logger_mt logger; - bool error (false); - auto store = nano::make_store (error, logger, nano::unique_path ()); - ASSERT_FALSE (error); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_FALSE (store->init_error ()); { auto transaction (store->tx_begin_write ()); ASSERT_EQ (0, store->online_weight_count (transaction)); @@ -1619,9 +1548,10 @@ TEST (mdb_block_store, upgrade_v13_v14) nano::logger_mt logger; nano::genesis genesis; auto error (false); - nano::mdb_store store (error, logger, path); + nano::mdb_store store (logger, path); auto transaction (store.tx_begin_write ()); - store.initialize (transaction, genesis); + nano::rep_weights rep_weights; + store.initialize (transaction, genesis, rep_weights); nano::account_info account_info; ASSERT_FALSE (store.account_get (transaction, nano::genesis_account, account_info)); uint64_t confirmation_height; @@ -1640,7 +1570,7 @@ TEST (mdb_block_store, upgrade_v13_v14) // Now do the upgrade nano::logger_mt logger; auto error (false); - nano::mdb_store store (error, logger, path); + nano::mdb_store store (logger, path); ASSERT_FALSE (error); auto transaction (store.tx_begin_read ()); @@ -1663,17 +1593,18 @@ TEST (mdb_block_store, upgrade_v13_v14) ASSERT_LT (13, store.version_get (transaction)); } -// Extract confirmation height to a separate database TEST (mdb_block_store, upgrade_v14_v15) { + // Extract confirmation height to a separate database auto path (nano::unique_path ()); { nano::logger_mt logger; nano::genesis genesis; auto error (false); - nano::mdb_store store (error, logger, path); + nano::mdb_store store (logger, path); auto transaction (store.tx_begin_write ()); - store.initialize (transaction, genesis); + nano::rep_weights rep_weights; + store.initialize (transaction, genesis, rep_weights); nano::account_info account_info; ASSERT_FALSE (store.account_get (transaction, nano::genesis_account, account_info)); uint64_t confirmation_height; @@ -1698,7 +1629,7 @@ TEST (mdb_block_store, upgrade_v14_v15) // Now do the upgrade nano::logger_mt logger; auto error (false); - nano::mdb_store store (error, logger, path); + nano::mdb_store store (logger, path); ASSERT_FALSE (error); auto transaction (store.tx_begin_read ()); @@ -1713,6 +1644,11 @@ TEST (mdb_block_store, upgrade_v14_v15) ASSERT_FALSE (store.confirmation_height_get (transaction, nano::genesis_account, confirmation_height)); ASSERT_EQ (confirmation_height, 1); + // The representation table should be deleted + auto error_get_representation (mdb_get (store.env.tx (transaction), store.representation, nano::mdb_val (nano::genesis_account), value)); + ASSERT_NE (error_get_representation, MDB_SUCCESS); + ASSERT_EQ (store.representation, 0); + // Version should be correct ASSERT_LT (14, store.version_get (transaction)); } @@ -1740,8 +1676,7 @@ TEST (mdb_block_store, upgrade_backup) { nano::logger_mt logger; nano::genesis genesis; - auto error (false); - nano::mdb_store store (error, logger, path); + nano::mdb_store store (logger, path); auto transaction (store.tx_begin_write ()); store.version_put (transaction, 14); } @@ -1749,9 +1684,8 @@ TEST (mdb_block_store, upgrade_backup) // Now do the upgrade and confirm that backup is saved nano::logger_mt logger; - auto error (false); - nano::mdb_store store (error, logger, path, nano::txn_tracking_config{}, std::chrono::seconds (5), 128, false, 512, true); - ASSERT_FALSE (error); + nano::mdb_store store (logger, path, nano::txn_tracking_config{}, std::chrono::seconds (5), 128, false, 512, true); + ASSERT_FALSE (store.init_error ()); auto transaction (store.tx_begin_read ()); ASSERT_LT (14, store.version_get (transaction)); ASSERT_NE (get_backup_path ().string (), dir.string ()); @@ -1763,7 +1697,7 @@ TEST (block_store, confirmation_height) auto path (nano::unique_path ()); nano::logger_mt logger; auto error (false); - nano::mdb_store store (error, logger, path); + nano::mdb_store store (logger, path); nano::account account1 (0); nano::account account2 (1); @@ -1806,11 +1740,12 @@ TEST (block_store, upgrade_confirmation_height_many) auto path (nano::unique_path ()); { nano::logger_mt logger; - nano::mdb_store store (error, logger, path); + nano::mdb_store store (logger, path); ASSERT_FALSE (error); auto transaction (store.tx_begin_write ()); store.version_put (transaction, 13); - store.initialize (transaction, genesis); + nano::rep_weights rep_weights; + store.initialize (transaction, genesis, rep_weights); modify_account_info_to_v13 (store, transaction, nano::genesis_account); // Add many accounts @@ -1828,7 +1763,7 @@ TEST (block_store, upgrade_confirmation_height_many) // Loop over them all and confirm they all have the correct confirmation heights nano::logger_mt logger; - nano::mdb_store store (error, logger, path); + nano::mdb_store store (logger, path); auto transaction (store.tx_begin_read ()); ASSERT_EQ (store.account_count (transaction), total_num_accounts); ASSERT_EQ (store.confirmation_height_count (transaction), total_num_accounts); @@ -1845,9 +1780,8 @@ TEST (block_store, incompatible_version) auto path (nano::unique_path ()); nano::logger_mt logger; { - auto error (false); - auto store = nano::make_store (error, logger, path); - ASSERT_FALSE (error); + auto store = nano::make_store (logger, path); + ASSERT_FALSE (store->init_error ()); // Put version to an unreachable number so that it should always be incompatible auto transaction (store->tx_begin_write ()); @@ -1856,9 +1790,8 @@ TEST (block_store, incompatible_version) // Now try and read it, should give an error { - auto error (false); - auto store = nano::make_store (error, logger, path, true); - ASSERT_TRUE (error); + auto store = nano::make_store (logger, path, true); + ASSERT_TRUE (store->init_error ()); auto transaction = store->tx_begin_read (); auto version_l = store->version_get (transaction); @@ -1869,9 +1802,8 @@ TEST (block_store, incompatible_version) TEST (block_store, reset_renew_existing_transaction) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); nano::keypair key1; nano::open_block block (0, 1, 1, nano::keypair ().prv, 0, 0); diff --git a/nano/core_test/ledger.cpp b/nano/core_test/ledger.cpp index 0e920842..ce83969c 100644 --- a/nano/core_test/ledger.cpp +++ b/nano/core_test/ledger.cpp @@ -13,9 +13,8 @@ using namespace std::chrono_literals; TEST (ledger, store_error) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, boost::filesystem::path ("///")); - ASSERT_TRUE (init); + auto store = nano::make_store (logger, boost::filesystem::path ("///")); + ASSERT_TRUE (store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); } @@ -25,9 +24,8 @@ TEST (ledger, store_error) TEST (ledger, empty) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); nano::account account; @@ -40,14 +38,13 @@ TEST (ledger, empty) TEST (ledger, genesis_balance) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); auto balance (ledger.account_balance (transaction, nano::genesis_account)); ASSERT_EQ (nano::genesis_amount, balance); auto amount (ledger.amount (transaction, nano::genesis_account)); @@ -78,14 +75,13 @@ TEST (system, system_genesis) TEST (ledger, process_send) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); auto transaction (store->tx_begin_write ()); nano::genesis genesis; - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); nano::account_info info1; ASSERT_FALSE (store->account_get (transaction, nano::test_genesis_key.pub, info1)); @@ -173,14 +169,13 @@ TEST (ledger, process_send) TEST (ledger, process_receive) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); nano::account_info info1; ASSERT_FALSE (store->account_get (transaction, nano::test_genesis_key.pub, info1)); @@ -232,14 +227,13 @@ TEST (ledger, process_receive) TEST (ledger, rollback_receiver) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); nano::account_info info1; ASSERT_FALSE (store->account_get (transaction, nano::test_genesis_key.pub, info1)); @@ -272,14 +266,13 @@ TEST (ledger, rollback_receiver) TEST (ledger, rollback_representation) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); nano::keypair key5; nano::change_block change1 (genesis.hash (), key5.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ())); @@ -327,14 +320,13 @@ TEST (ledger, rollback_representation) TEST (ledger, receive_rollback) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); nano::send_block send (genesis.hash (), nano::test_genesis_key.pub, nano::genesis_amount - nano::Gxrb_ratio, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send).code); @@ -346,14 +338,13 @@ TEST (ledger, receive_rollback) TEST (ledger, process_duplicate) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); nano::account_info info1; ASSERT_FALSE (store->account_get (transaction, nano::test_genesis_key.pub, info1)); @@ -370,14 +361,13 @@ TEST (ledger, process_duplicate) TEST (ledger, representative_genesis) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); auto latest (ledger.latest (transaction, nano::test_genesis_key.pub)); ASSERT_FALSE (latest.is_zero ()); ASSERT_EQ (genesis.open->hash (), ledger.representative (transaction, latest)); @@ -386,29 +376,27 @@ TEST (ledger, representative_genesis) TEST (ledger, weight) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); ASSERT_EQ (nano::genesis_amount, ledger.weight (transaction, nano::genesis_account)); } TEST (ledger, representative_change) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); nano::keypair key2; nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); ASSERT_EQ (nano::genesis_amount, ledger.weight (transaction, nano::test_genesis_key.pub)); ASSERT_EQ (0, ledger.weight (transaction, key2.pub)); @@ -440,16 +428,15 @@ TEST (ledger, representative_change) TEST (ledger, send_fork) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); nano::keypair key2; nano::keypair key3; nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); nano::account_info info1; ASSERT_FALSE (store->account_get (transaction, nano::test_genesis_key.pub, info1)); @@ -462,16 +449,15 @@ TEST (ledger, send_fork) TEST (ledger, receive_fork) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); nano::keypair key2; nano::keypair key3; nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); nano::account_info info1; ASSERT_FALSE (store->account_get (transaction, nano::test_genesis_key.pub, info1)); @@ -490,16 +476,15 @@ TEST (ledger, receive_fork) TEST (ledger, open_fork) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); nano::keypair key2; nano::keypair key3; nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); nano::account_info info1; ASSERT_FALSE (store->account_get (transaction, nano::test_genesis_key.pub, info1)); @@ -608,92 +593,102 @@ TEST (system, generate_send_new) runner.join (); } +TEST (ledger, representation_changes) +{ + nano::keypair key1; + nano::rep_weights rep_weights; + ASSERT_EQ (0, rep_weights.representation_get (key1.pub)); + rep_weights.representation_put (key1.pub, 1); + ASSERT_EQ (1, rep_weights.representation_get (key1.pub)); + rep_weights.representation_put (key1.pub, 2); + ASSERT_EQ (2, rep_weights.representation_get (key1.pub)); +} + TEST (ledger, representation) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); + auto & rep_weights = ledger.rep_weights; nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, rep_weights); nano::work_pool pool (std::numeric_limits::max ()); - ASSERT_EQ (nano::genesis_amount, store->representation_get (transaction, nano::test_genesis_key.pub)); + ASSERT_EQ (nano::genesis_amount, rep_weights.representation_get (nano::test_genesis_key.pub)); nano::keypair key2; nano::send_block block1 (genesis.hash (), key2.pub, nano::genesis_amount - 100, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block1).code); - ASSERT_EQ (nano::genesis_amount - 100, store->representation_get (transaction, nano::test_genesis_key.pub)); + ASSERT_EQ (nano::genesis_amount - 100, rep_weights.representation_get (nano::test_genesis_key.pub)); nano::keypair key3; nano::open_block block2 (block1.hash (), key3.pub, key2.pub, key2.prv, key2.pub, pool.generate (key2.pub)); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block2).code); - ASSERT_EQ (nano::genesis_amount - 100, store->representation_get (transaction, nano::test_genesis_key.pub)); - ASSERT_EQ (0, store->representation_get (transaction, key2.pub)); - ASSERT_EQ (100, store->representation_get (transaction, key3.pub)); + ASSERT_EQ (nano::genesis_amount - 100, rep_weights.representation_get (nano::test_genesis_key.pub)); + ASSERT_EQ (0, rep_weights.representation_get (key2.pub)); + ASSERT_EQ (100, rep_weights.representation_get (key3.pub)); nano::send_block block3 (block1.hash (), key2.pub, nano::genesis_amount - 200, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (block1.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block3).code); - ASSERT_EQ (nano::genesis_amount - 200, store->representation_get (transaction, nano::test_genesis_key.pub)); - ASSERT_EQ (0, store->representation_get (transaction, key2.pub)); - ASSERT_EQ (100, store->representation_get (transaction, key3.pub)); + ASSERT_EQ (nano::genesis_amount - 200, rep_weights.representation_get (nano::test_genesis_key.pub)); + ASSERT_EQ (0, rep_weights.representation_get (key2.pub)); + ASSERT_EQ (100, rep_weights.representation_get (key3.pub)); nano::receive_block block4 (block2.hash (), block3.hash (), key2.prv, key2.pub, pool.generate (block2.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block4).code); - ASSERT_EQ (nano::genesis_amount - 200, store->representation_get (transaction, nano::test_genesis_key.pub)); - ASSERT_EQ (0, store->representation_get (transaction, key2.pub)); - ASSERT_EQ (200, store->representation_get (transaction, key3.pub)); + ASSERT_EQ (nano::genesis_amount - 200, rep_weights.representation_get (nano::test_genesis_key.pub)); + ASSERT_EQ (0, rep_weights.representation_get (key2.pub)); + ASSERT_EQ (200, rep_weights.representation_get (key3.pub)); nano::keypair key4; nano::change_block block5 (block4.hash (), key4.pub, key2.prv, key2.pub, pool.generate (block4.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block5).code); - ASSERT_EQ (nano::genesis_amount - 200, store->representation_get (transaction, nano::test_genesis_key.pub)); - ASSERT_EQ (0, store->representation_get (transaction, key2.pub)); - ASSERT_EQ (0, store->representation_get (transaction, key3.pub)); - ASSERT_EQ (200, store->representation_get (transaction, key4.pub)); + ASSERT_EQ (nano::genesis_amount - 200, rep_weights.representation_get (nano::test_genesis_key.pub)); + ASSERT_EQ (0, rep_weights.representation_get (key2.pub)); + ASSERT_EQ (0, rep_weights.representation_get (key3.pub)); + ASSERT_EQ (200, rep_weights.representation_get (key4.pub)); nano::keypair key5; nano::send_block block6 (block5.hash (), key5.pub, 100, key2.prv, key2.pub, pool.generate (block5.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block6).code); - ASSERT_EQ (nano::genesis_amount - 200, store->representation_get (transaction, nano::test_genesis_key.pub)); - ASSERT_EQ (0, store->representation_get (transaction, key2.pub)); - ASSERT_EQ (0, store->representation_get (transaction, key3.pub)); - ASSERT_EQ (100, store->representation_get (transaction, key4.pub)); - ASSERT_EQ (0, store->representation_get (transaction, key5.pub)); + ASSERT_EQ (nano::genesis_amount - 200, rep_weights.representation_get (nano::test_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); - ASSERT_EQ (nano::genesis_amount - 200, store->representation_get (transaction, nano::test_genesis_key.pub)); - ASSERT_EQ (0, store->representation_get (transaction, key2.pub)); - ASSERT_EQ (0, store->representation_get (transaction, key3.pub)); - ASSERT_EQ (100, store->representation_get (transaction, key4.pub)); - ASSERT_EQ (0, store->representation_get (transaction, key5.pub)); - ASSERT_EQ (100, store->representation_get (transaction, key6.pub)); + ASSERT_EQ (nano::genesis_amount - 200, rep_weights.representation_get (nano::test_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); - ASSERT_EQ (nano::genesis_amount - 200, store->representation_get (transaction, nano::test_genesis_key.pub)); - ASSERT_EQ (0, store->representation_get (transaction, key2.pub)); - ASSERT_EQ (0, store->representation_get (transaction, key3.pub)); - ASSERT_EQ (0, store->representation_get (transaction, key4.pub)); - ASSERT_EQ (0, store->representation_get (transaction, key5.pub)); - ASSERT_EQ (100, store->representation_get (transaction, key6.pub)); + ASSERT_EQ (nano::genesis_amount - 200, rep_weights.representation_get (nano::test_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); - ASSERT_EQ (nano::genesis_amount - 200, store->representation_get (transaction, nano::test_genesis_key.pub)); - ASSERT_EQ (0, store->representation_get (transaction, key2.pub)); - ASSERT_EQ (0, store->representation_get (transaction, key3.pub)); - ASSERT_EQ (0, store->representation_get (transaction, key4.pub)); - ASSERT_EQ (0, store->representation_get (transaction, key5.pub)); - ASSERT_EQ (200, store->representation_get (transaction, key6.pub)); + ASSERT_EQ (nano::genesis_amount - 200, rep_weights.representation_get (nano::test_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 (200, rep_weights.representation_get (key6.pub)); } TEST (ledger, double_open) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); nano::keypair key2; nano::send_block send1 (genesis.hash (), key2.pub, 1, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ())); @@ -707,14 +702,13 @@ TEST (ledger, double_open) TEST (ledger, double_receive) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); nano::keypair key2; nano::send_block send1 (genesis.hash (), key2.pub, 1, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ())); @@ -981,14 +975,13 @@ TEST (ledger, successor) TEST (ledger, fail_change_old) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_FALSE (init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_FALSE (store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); nano::keypair key1; nano::change_block block (genesis.hash (), key1.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ())); @@ -1001,14 +994,13 @@ TEST (ledger, fail_change_old) TEST (ledger, fail_change_gap_previous) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_FALSE (init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_FALSE (store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); nano::keypair key1; nano::change_block block (1, key1.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (1)); @@ -1019,14 +1011,13 @@ TEST (ledger, fail_change_gap_previous) TEST (ledger, fail_change_bad_signature) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_FALSE (init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_FALSE (store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); nano::keypair key1; nano::change_block block (genesis.hash (), key1.pub, nano::keypair ().prv, 0, pool.generate (genesis.hash ())); @@ -1037,14 +1028,13 @@ TEST (ledger, fail_change_bad_signature) TEST (ledger, fail_change_fork) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_FALSE (init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_FALSE (store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); nano::keypair key1; nano::change_block block1 (genesis.hash (), key1.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ())); @@ -1059,14 +1049,13 @@ TEST (ledger, fail_change_fork) TEST (ledger, fail_send_old) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_FALSE (init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_FALSE (store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); nano::keypair key1; nano::send_block block (genesis.hash (), key1.pub, 1, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ())); @@ -1079,14 +1068,13 @@ TEST (ledger, fail_send_old) TEST (ledger, fail_send_gap_previous) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_FALSE (init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_FALSE (store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); nano::keypair key1; nano::send_block block (1, key1.pub, 1, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (1)); @@ -1097,14 +1085,13 @@ TEST (ledger, fail_send_gap_previous) TEST (ledger, fail_send_bad_signature) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_FALSE (init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_FALSE (store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); nano::keypair key1; nano::send_block block (genesis.hash (), key1.pub, 1, nano::keypair ().prv, 0, pool.generate (genesis.hash ())); @@ -1115,14 +1102,13 @@ TEST (ledger, fail_send_bad_signature) TEST (ledger, fail_send_negative_spend) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_FALSE (init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_FALSE (store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); nano::keypair key1; nano::send_block block1 (genesis.hash (), key1.pub, 1, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ())); @@ -1135,14 +1121,13 @@ TEST (ledger, fail_send_negative_spend) TEST (ledger, fail_send_fork) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_FALSE (init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_FALSE (store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); nano::keypair key1; nano::send_block block1 (genesis.hash (), key1.pub, 1, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ())); @@ -1155,14 +1140,13 @@ TEST (ledger, fail_send_fork) TEST (ledger, fail_open_old) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_FALSE (init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_FALSE (store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); nano::keypair key1; nano::send_block block1 (genesis.hash (), key1.pub, 1, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ())); @@ -1175,14 +1159,13 @@ TEST (ledger, fail_open_old) TEST (ledger, fail_open_gap_source) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_FALSE (init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_FALSE (store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); nano::keypair key1; nano::open_block block2 (1, 1, key1.pub, key1.prv, key1.pub, pool.generate (key1.pub)); @@ -1193,14 +1176,13 @@ TEST (ledger, fail_open_gap_source) TEST (ledger, fail_open_bad_signature) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_FALSE (init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_FALSE (store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); nano::keypair key1; nano::send_block block1 (genesis.hash (), key1.pub, 1, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ())); @@ -1213,14 +1195,13 @@ TEST (ledger, fail_open_bad_signature) TEST (ledger, fail_open_fork_previous) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_FALSE (init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_FALSE (store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); nano::keypair key1; nano::send_block block1 (genesis.hash (), key1.pub, 1, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ())); @@ -1236,14 +1217,13 @@ TEST (ledger, fail_open_fork_previous) TEST (ledger, fail_open_account_mismatch) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_FALSE (init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_FALSE (store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); nano::keypair key1; nano::send_block block1 (genesis.hash (), key1.pub, 1, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ())); @@ -1256,14 +1236,13 @@ TEST (ledger, fail_open_account_mismatch) TEST (ledger, fail_receive_old) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_FALSE (init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_FALSE (store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); nano::keypair key1; nano::send_block block1 (genesis.hash (), key1.pub, 1, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ())); @@ -1280,14 +1259,13 @@ TEST (ledger, fail_receive_old) TEST (ledger, fail_receive_gap_source) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_FALSE (init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_FALSE (store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); nano::keypair key1; nano::send_block block1 (genesis.hash (), key1.pub, 1, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ())); @@ -1307,14 +1285,13 @@ TEST (ledger, fail_receive_gap_source) TEST (ledger, fail_receive_overreceive) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_FALSE (init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_FALSE (store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); nano::keypair key1; nano::send_block block1 (genesis.hash (), key1.pub, 1, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ())); @@ -1331,14 +1308,13 @@ TEST (ledger, fail_receive_overreceive) TEST (ledger, fail_receive_bad_signature) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_FALSE (init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_FALSE (store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); nano::keypair key1; nano::send_block block1 (genesis.hash (), key1.pub, 1, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ())); @@ -1358,14 +1334,13 @@ TEST (ledger, fail_receive_bad_signature) TEST (ledger, fail_receive_gap_previous_opened) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_FALSE (init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_FALSE (store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); nano::keypair key1; nano::send_block block1 (genesis.hash (), key1.pub, 1, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ())); @@ -1385,14 +1360,13 @@ TEST (ledger, fail_receive_gap_previous_opened) TEST (ledger, fail_receive_gap_previous_unopened) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_FALSE (init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_FALSE (store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); nano::keypair key1; nano::send_block block1 (genesis.hash (), key1.pub, 1, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ())); @@ -1409,14 +1383,13 @@ TEST (ledger, fail_receive_gap_previous_unopened) TEST (ledger, fail_receive_fork_previous) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_FALSE (init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_FALSE (store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); nano::keypair key1; nano::send_block block1 (genesis.hash (), key1.pub, 1, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ())); @@ -1440,14 +1413,13 @@ TEST (ledger, fail_receive_fork_previous) TEST (ledger, fail_receive_received_source) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_FALSE (init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_FALSE (store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); nano::keypair key1; nano::send_block block1 (genesis.hash (), key1.pub, 2, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ())); @@ -1477,9 +1449,8 @@ TEST (ledger, fail_receive_received_source) TEST (ledger, latest_empty) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_FALSE (init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_FALSE (store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); nano::keypair key; @@ -1491,14 +1462,13 @@ TEST (ledger, latest_empty) TEST (ledger, latest_root) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_FALSE (init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_FALSE (store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); nano::keypair key; ASSERT_EQ (key.pub, ledger.latest_root (transaction, key.pub)); @@ -1511,15 +1481,14 @@ TEST (ledger, latest_root) TEST (ledger, change_representative_move_representation) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); nano::keypair key1; auto transaction (store->tx_begin_write ()); nano::genesis genesis; - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); auto hash1 (genesis.hash ()); ASSERT_EQ (nano::genesis_amount, ledger.weight (transaction, nano::test_genesis_key.pub)); @@ -1538,14 +1507,13 @@ TEST (ledger, change_representative_move_representation) TEST (ledger, send_open_receive_rollback) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); auto transaction (store->tx_begin_write ()); nano::genesis genesis; - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); nano::account_info info1; ASSERT_FALSE (store->account_get (transaction, nano::test_genesis_key.pub, info1)); @@ -1598,9 +1566,8 @@ TEST (ledger, send_open_receive_rollback) TEST (ledger, bootstrap_rep_weight) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); nano::account_info info1; @@ -1609,7 +1576,7 @@ TEST (ledger, bootstrap_rep_weight) nano::work_pool pool (std::numeric_limits::max ()); { auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); ASSERT_FALSE (store->account_get (transaction, nano::test_genesis_key.pub, info1)); nano::send_block send (info1.head, key2.pub, std::numeric_limits::max () - 50, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (info1.head)); ledger.process (transaction, send); @@ -1635,14 +1602,13 @@ TEST (ledger, bootstrap_rep_weight) TEST (ledger, block_destination_source) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); nano::keypair dest; nano::uint128_t balance (nano::genesis_amount); @@ -1682,14 +1648,13 @@ TEST (ledger, block_destination_source) TEST (ledger, state_account) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, nano::genesis_account, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); @@ -1699,14 +1664,13 @@ TEST (ledger, state_account) TEST (ledger, state_send_receive) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, nano::genesis_account, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); @@ -1733,14 +1697,13 @@ TEST (ledger, state_send_receive) TEST (ledger, state_receive) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); nano::send_block send1 (genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); @@ -1765,14 +1728,13 @@ TEST (ledger, state_receive) TEST (ledger, state_rep_change) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); nano::keypair rep; nano::state_block change1 (nano::genesis_account, genesis.hash (), rep.pub, nano::genesis_amount, 0, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ())); @@ -1790,14 +1752,13 @@ TEST (ledger, state_rep_change) TEST (ledger, state_open) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); nano::keypair destination; nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, destination.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ())); @@ -1826,14 +1787,13 @@ TEST (ledger, state_open) TEST (ledger, send_after_state_fail) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, nano::genesis_account, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); @@ -1845,14 +1805,13 @@ TEST (ledger, send_after_state_fail) TEST (ledger, receive_after_state_fail) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, nano::genesis_account, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); @@ -1864,14 +1823,13 @@ TEST (ledger, receive_after_state_fail) TEST (ledger, change_after_state_fail) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, nano::genesis_account, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); @@ -1883,14 +1841,13 @@ TEST (ledger, change_after_state_fail) TEST (ledger, state_unreceivable_fail) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); nano::send_block send1 (genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); @@ -1908,14 +1865,13 @@ TEST (ledger, state_unreceivable_fail) TEST (ledger, state_receive_bad_amount_fail) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); nano::send_block send1 (genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); @@ -1933,14 +1889,13 @@ TEST (ledger, state_receive_bad_amount_fail) TEST (ledger, state_no_link_amount_fail) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, nano::genesis_account, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); @@ -1952,14 +1907,13 @@ TEST (ledger, state_no_link_amount_fail) TEST (ledger, state_receive_wrong_account_fail) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, nano::genesis_account, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); @@ -1978,14 +1932,13 @@ TEST (ledger, state_receive_wrong_account_fail) TEST (ledger, state_open_state_fork) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); nano::keypair destination; nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, destination.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ())); @@ -2000,14 +1953,13 @@ TEST (ledger, state_open_state_fork) TEST (ledger, state_state_open_fork) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); nano::keypair destination; nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, destination.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ())); @@ -2022,14 +1974,13 @@ TEST (ledger, state_state_open_fork) TEST (ledger, state_open_previous_fail) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); nano::keypair destination; nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, destination.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ())); @@ -2041,14 +1992,13 @@ TEST (ledger, state_open_previous_fail) TEST (ledger, state_open_source_fail) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); nano::keypair destination; nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, destination.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ())); @@ -2060,14 +2010,13 @@ TEST (ledger, state_open_source_fail) TEST (ledger, state_send_change) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); nano::keypair rep; nano::state_block send1 (nano::genesis_account, genesis.hash (), rep.pub, nano::genesis_amount - nano::Gxrb_ratio, nano::genesis_account, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ())); @@ -2085,14 +2034,13 @@ TEST (ledger, state_send_change) TEST (ledger, state_receive_change) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, nano::genesis_account, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); @@ -2119,14 +2067,13 @@ TEST (ledger, state_receive_change) TEST (ledger, state_open_old) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); nano::keypair destination; nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, destination.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ())); @@ -2141,14 +2088,13 @@ TEST (ledger, state_open_old) TEST (ledger, state_receive_old) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); nano::keypair destination; nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, destination.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ())); @@ -2167,14 +2113,13 @@ TEST (ledger, state_receive_old) TEST (ledger, state_rollback_send) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, nano::genesis_account, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); @@ -2199,14 +2144,13 @@ TEST (ledger, state_rollback_send) TEST (ledger, state_rollback_receive) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, nano::genesis_account, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); @@ -2226,14 +2170,13 @@ TEST (ledger, state_rollback_receive) TEST (ledger, state_rollback_received_send) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); nano::keypair key; nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, key.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ())); @@ -2254,14 +2197,13 @@ TEST (ledger, state_rollback_received_send) TEST (ledger, state_rep_change_rollback) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); nano::keypair rep; nano::state_block change1 (nano::genesis_account, genesis.hash (), rep.pub, nano::genesis_amount, 0, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ())); @@ -2276,14 +2218,13 @@ TEST (ledger, state_rep_change_rollback) TEST (ledger, state_open_rollback) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); nano::keypair destination; nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, destination.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ())); @@ -2303,14 +2244,13 @@ TEST (ledger, state_open_rollback) TEST (ledger, state_send_change_rollback) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); nano::keypair rep; nano::state_block send1 (nano::genesis_account, genesis.hash (), rep.pub, nano::genesis_amount - nano::Gxrb_ratio, nano::genesis_account, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ())); @@ -2325,14 +2265,13 @@ TEST (ledger, state_send_change_rollback) TEST (ledger, state_receive_change_rollback) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, nano::genesis_account, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); @@ -2349,15 +2288,14 @@ TEST (ledger, state_receive_change_rollback) TEST (ledger, epoch_blocks_general) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); nano::stat stats; nano::keypair epoch_key; nano::ledger ledger (*store, stats, 123, epoch_key.pub); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); nano::keypair destination; nano::state_block epoch1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount, 123, epoch_key.prv, epoch_key.pub, pool.generate (genesis.hash ())); @@ -2397,15 +2335,14 @@ TEST (ledger, epoch_blocks_general) TEST (ledger, epoch_blocks_receive_upgrade) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); nano::stat stats; nano::keypair epoch_key; nano::ledger ledger (*store, stats, 123, epoch_key.pub); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); nano::keypair destination; nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, destination.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ())); @@ -2439,15 +2376,14 @@ TEST (ledger, epoch_blocks_receive_upgrade) TEST (ledger, epoch_blocks_fork) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); nano::stat stats; nano::keypair epoch_key; nano::ledger ledger (*store, stats, 123, epoch_key.pub); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); nano::keypair destination; nano::send_block send1 (genesis.hash (), nano::account (0), nano::genesis_amount, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ())); @@ -2568,9 +2504,8 @@ TEST (ledger, block_hash_account_conflict) TEST (ledger, could_fit) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_TRUE (!init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); nano::stat stats; nano::keypair epoch_key; nano::ledger ledger (*store, stats, 123, epoch_key.pub); @@ -2579,7 +2514,7 @@ TEST (ledger, could_fit) ledger.epoch_signer = epoch_signer.pub; nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); nano::keypair destination; // Test legacy and state change blocks could_fit @@ -2796,15 +2731,14 @@ TEST (ledger, unchecked_receive) TEST (ledger, confirmation_height_not_updated) { - bool error (false); nano::logger_mt logger; - auto store = nano::make_store (error, logger, nano::unique_path ()); - ASSERT_TRUE (!error); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_TRUE (!store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); auto transaction (store->tx_begin_write ()); nano::genesis genesis; - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); nano::account_info account_info; ASSERT_FALSE (store->account_get (transaction, nano::test_genesis_key.pub, account_info)); diff --git a/nano/core_test/network.cpp b/nano/core_test/network.cpp index c4809fa2..c91ebf0d 100644 --- a/nano/core_test/network.cpp +++ b/nano/core_test/network.cpp @@ -70,8 +70,7 @@ TEST (network, send_node_id_handshake) { nano::system system (24000, 1); ASSERT_EQ (0, system.nodes[0]->network.size ()); - nano::node_init init1; - auto node1 (std::make_shared (init1, system.io_ctx, 24001, nano::unique_path (), system.alarm, system.logging, system.work)); + auto node1 (std::make_shared (system.io_ctx, 24001, nano::unique_path (), system.alarm, system.logging, system.work)); node1->start (); system.nodes.push_back (node1); auto initial (system.nodes[0]->stats.count (nano::stat::type::message, nano::stat::detail::node_id_handshake, nano::stat::dir::in)); @@ -105,8 +104,7 @@ TEST (network, send_node_id_handshake_tcp) { nano::system system (24000, 1); ASSERT_EQ (0, system.nodes[0]->network.size ()); - nano::node_init init1; - auto node1 (std::make_shared (init1, system.io_ctx, 24001, nano::unique_path (), system.alarm, system.logging, system.work)); + auto node1 (std::make_shared (system.io_ctx, 24001, nano::unique_path (), system.alarm, system.logging, system.work)); node1->start (); system.nodes.push_back (node1); auto initial (system.nodes[0]->stats.count (nano::stat::type::message, nano::stat::detail::node_id_handshake, nano::stat::dir::in)); @@ -161,8 +159,7 @@ TEST (network, last_contacted) { nano::system system (24000, 1); ASSERT_EQ (0, system.nodes[0]->network.size ()); - nano::node_init init1; - auto node1 (std::make_shared (init1, system.io_ctx, 24001, nano::unique_path (), system.alarm, system.logging, system.work)); + auto node1 (std::make_shared (system.io_ctx, 24001, nano::unique_path (), system.alarm, system.logging, system.work)); node1->start (); system.nodes.push_back (node1); auto channel1 (std::make_shared (node1->network.udp_channels, nano::endpoint (boost::asio::ip::address_v6::loopback (), 24000), node1->network_params.protocol.protocol_version)); @@ -196,9 +193,8 @@ TEST (network, multi_keepalive) { nano::system system (24000, 1); ASSERT_EQ (0, system.nodes[0]->network.size ()); - nano::node_init init1; - auto node1 (std::make_shared (init1, system.io_ctx, 24001, nano::unique_path (), system.alarm, system.logging, system.work)); - ASSERT_FALSE (init1.error ()); + auto node1 (std::make_shared (system.io_ctx, 24001, nano::unique_path (), system.alarm, system.logging, system.work)); + ASSERT_FALSE (node1->init_error ()); node1->start (); system.nodes.push_back (node1); ASSERT_EQ (0, node1->network.size ()); @@ -211,9 +207,8 @@ TEST (network, multi_keepalive) { ASSERT_NO_ERROR (system.poll ()); } - nano::node_init init2; - auto node2 (std::make_shared (init2, system.io_ctx, 24002, nano::unique_path (), system.alarm, system.logging, system.work)); - ASSERT_FALSE (init2.error ()); + auto node2 (std::make_shared (system.io_ctx, 24002, nano::unique_path (), system.alarm, system.logging, system.work)); + ASSERT_FALSE (node2->init_error ()); node2->start (); system.nodes.push_back (node2); auto channel2 (std::make_shared (node2->network.udp_channels, system.nodes[0]->network.endpoint (), node2->network_params.protocol.protocol_version)); @@ -635,9 +630,8 @@ TEST (bulk_pull, count_limit) TEST (bootstrap_processor, DISABLED_process_none) { nano::system system (24000, 1); - nano::node_init init1; - auto node1 (std::make_shared (init1, system.io_ctx, 24001, nano::unique_path (), system.alarm, system.logging, system.work)); - ASSERT_FALSE (init1.error ()); + auto node1 (std::make_shared (system.io_ctx, 24001, nano::unique_path (), system.alarm, system.logging, system.work)); + ASSERT_FALSE (node1->init_error ()); auto done (false); node1->bootstrap_initiator.bootstrap (system.nodes[0]->network.endpoint ()); while (!done) @@ -653,8 +647,7 @@ TEST (bootstrap_processor, process_one) nano::system system (24000, 1); system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::test_genesis_key.pub, nano::test_genesis_key.pub, 100)); - nano::node_init init1; - auto node1 (std::make_shared (init1, system.io_ctx, 24001, nano::unique_path (), system.alarm, system.logging, system.work)); + auto node1 (std::make_shared (system.io_ctx, 24001, nano::unique_path (), system.alarm, system.logging, system.work)); nano::block_hash hash1 (system.nodes[0]->latest (nano::test_genesis_key.pub)); nano::block_hash hash2 (node1->latest (nano::test_genesis_key.pub)); ASSERT_NE (hash1, hash2); @@ -681,9 +674,8 @@ TEST (bootstrap_processor, process_two) ASSERT_NE (hash1, hash2); ASSERT_NE (hash1, hash3); ASSERT_NE (hash2, hash3); - nano::node_init init1; - auto node1 (std::make_shared (init1, system.io_ctx, 24001, nano::unique_path (), system.alarm, system.logging, system.work)); - ASSERT_FALSE (init1.error ()); + auto node1 (std::make_shared (system.io_ctx, 24001, nano::unique_path (), system.alarm, system.logging, system.work)); + ASSERT_FALSE (node1->init_error ()); node1->bootstrap_initiator.bootstrap (system.nodes[0]->network.endpoint ()); ASSERT_NE (node1->latest (nano::test_genesis_key.pub), system.nodes[0]->latest (nano::test_genesis_key.pub)); system.deadline_set (10s); @@ -707,8 +699,7 @@ TEST (bootstrap_processor, process_state) node0->work_generate_blocking (*block2); node0->process (*block1); node0->process (*block2); - nano::node_init init1; - auto node1 (std::make_shared (init1, system.io_ctx, 24001, nano::unique_path (), system.alarm, system.logging, system.work)); + auto node1 (std::make_shared (system.io_ctx, 24001, nano::unique_path (), system.alarm, system.logging, system.work)); ASSERT_EQ (node0->latest (nano::test_genesis_key.pub), block2->hash ()); ASSERT_NE (node1->latest (nano::test_genesis_key.pub), block2->hash ()); node1->bootstrap_initiator.bootstrap (node0->network.endpoint ()); @@ -736,9 +727,8 @@ TEST (bootstrap_processor, process_new) } nano::uint128_t balance1 (system.nodes[0]->balance (nano::test_genesis_key.pub)); nano::uint128_t balance2 (system.nodes[0]->balance (key2.pub)); - nano::node_init init1; - auto node1 (std::make_shared (init1, system.io_ctx, 24002, nano::unique_path (), system.alarm, system.logging, system.work)); - ASSERT_FALSE (init1.error ()); + auto node1 (std::make_shared (system.io_ctx, 24002, nano::unique_path (), system.alarm, system.logging, system.work)); + ASSERT_FALSE (node1->init_error ()); node1->bootstrap_initiator.bootstrap (system.nodes[0]->network.endpoint ()); system.deadline_set (10s); while (node1->balance (key2.pub) != balance2) @@ -761,9 +751,8 @@ TEST (bootstrap_processor, pull_diamond) ASSERT_EQ (nano::process_result::progress, system.nodes[0]->process (*send2).code); auto receive (std::make_shared (send1->hash (), send2->hash (), nano::test_genesis_key.prv, nano::test_genesis_key.pub, system.work.generate (send1->hash ()))); ASSERT_EQ (nano::process_result::progress, system.nodes[0]->process (*receive).code); - nano::node_init init1; - auto node1 (std::make_shared (init1, system.io_ctx, 24002, nano::unique_path (), system.alarm, system.logging, system.work)); - ASSERT_FALSE (init1.error ()); + auto node1 (std::make_shared (system.io_ctx, 24002, nano::unique_path (), system.alarm, system.logging, system.work)); + ASSERT_FALSE (node1->init_error ()); node1->bootstrap_initiator.bootstrap (system.nodes[0]->network.endpoint ()); system.deadline_set (10s); while (node1->balance (nano::test_genesis_key.pub) != 100) @@ -778,9 +767,8 @@ TEST (bootstrap_processor, push_diamond) { nano::system system (24000, 1); nano::keypair key; - nano::node_init init1; - auto node1 (std::make_shared (init1, system.io_ctx, 24002, nano::unique_path (), system.alarm, system.logging, system.work)); - ASSERT_FALSE (init1.error ()); + auto node1 (std::make_shared (system.io_ctx, 24002, nano::unique_path (), system.alarm, system.logging, system.work)); + ASSERT_FALSE (node1->init_error ()); auto wallet1 (node1->wallets.create (100)); wallet1->insert_adhoc (nano::test_genesis_key.prv); wallet1->insert_adhoc (key.prv); @@ -805,9 +793,8 @@ TEST (bootstrap_processor, push_diamond) TEST (bootstrap_processor, push_one) { nano::system system (24000, 1); - nano::node_init init1; nano::keypair key1; - auto node1 (std::make_shared (init1, system.io_ctx, 24001, nano::unique_path (), system.alarm, system.logging, system.work)); + auto node1 (std::make_shared (system.io_ctx, 24001, nano::unique_path (), system.alarm, system.logging, system.work)); auto wallet (node1->wallets.create (nano::uint256_union ())); ASSERT_NE (nullptr, wallet); wallet->insert_adhoc (nano::test_genesis_key.prv); @@ -826,7 +813,6 @@ TEST (bootstrap_processor, push_one) TEST (bootstrap_processor, lazy_hash) { nano::system system (24000, 1); - nano::node_init init1; nano::genesis genesis; nano::keypair key1; nano::keypair key2; @@ -842,7 +828,7 @@ TEST (bootstrap_processor, lazy_hash) system.nodes[0]->block_processor.add (receive2); system.nodes[0]->block_processor.flush (); // Start lazy bootstrap with last block in chain known - auto node1 (std::make_shared (init1, system.io_ctx, 24001, nano::unique_path (), system.alarm, system.logging, system.work)); + auto node1 (std::make_shared (system.io_ctx, 24001, nano::unique_path (), system.alarm, system.logging, system.work)); node1->network.udp_channels.insert (system.nodes[0]->network.endpoint (), node1->network_params.protocol.protocol_version); node1->bootstrap_initiator.bootstrap_lazy (receive2->hash ()); // Check processed blocks @@ -857,7 +843,6 @@ TEST (bootstrap_processor, lazy_hash) TEST (bootstrap_processor, lazy_max_pull_count) { nano::system system (24000, 1); - nano::node_init init1; nano::genesis genesis; nano::keypair key1; nano::keypair key2; @@ -879,7 +864,7 @@ TEST (bootstrap_processor, lazy_max_pull_count) system.nodes[0]->block_processor.add (change3); system.nodes[0]->block_processor.flush (); // Start lazy bootstrap with last block in chain known - auto node1 (std::make_shared (init1, system.io_ctx, 24001, nano::unique_path (), system.alarm, system.logging, system.work)); + auto node1 (std::make_shared (system.io_ctx, 24001, nano::unique_path (), system.alarm, system.logging, system.work)); node1->network.udp_channels.insert (system.nodes[0]->network.endpoint (), node1->network_params.protocol.protocol_version); node1->bootstrap_initiator.bootstrap_lazy (change3->hash ()); // Check processed blocks @@ -894,7 +879,6 @@ TEST (bootstrap_processor, lazy_max_pull_count) TEST (bootstrap_processor, wallet_lazy_frontier) { nano::system system (24000, 1); - nano::node_init init1; nano::genesis genesis; nano::keypair key1; nano::keypair key2; @@ -910,7 +894,7 @@ TEST (bootstrap_processor, wallet_lazy_frontier) system.nodes[0]->block_processor.add (receive2); system.nodes[0]->block_processor.flush (); // Start wallet lazy bootstrap - auto node1 (std::make_shared (init1, system.io_ctx, 24001, nano::unique_path (), system.alarm, system.logging, system.work)); + auto node1 (std::make_shared (system.io_ctx, 24001, nano::unique_path (), system.alarm, system.logging, system.work)); node1->network.udp_channels.insert (system.nodes[0]->network.endpoint (), node1->network_params.protocol.protocol_version); auto wallet (node1->wallets.create (nano::uint256_union ())); ASSERT_NE (nullptr, wallet); @@ -928,7 +912,6 @@ TEST (bootstrap_processor, wallet_lazy_frontier) TEST (bootstrap_processor, wallet_lazy_pending) { nano::system system (24000, 1); - nano::node_init init1; nano::genesis genesis; nano::keypair key1; nano::keypair key2; @@ -942,7 +925,7 @@ TEST (bootstrap_processor, wallet_lazy_pending) system.nodes[0]->block_processor.add (send2); system.nodes[0]->block_processor.flush (); // Start wallet lazy bootstrap - auto node1 (std::make_shared (init1, system.io_ctx, 24001, nano::unique_path (), system.alarm, system.logging, system.work)); + auto node1 (std::make_shared (system.io_ctx, 24001, nano::unique_path (), system.alarm, system.logging, system.work)); node1->network.udp_channels.insert (system.nodes[0]->network.endpoint (), node1->network_params.protocol.protocol_version); auto wallet (node1->wallets.create (nano::uint256_union ())); ASSERT_NE (nullptr, wallet); @@ -1079,9 +1062,8 @@ TEST (bulk, genesis) { nano::system system (24000, 1); system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); - nano::node_init init1; - auto node1 (std::make_shared (init1, system.io_ctx, 24001, nano::unique_path (), system.alarm, system.logging, system.work)); - ASSERT_FALSE (init1.error ()); + auto node1 (std::make_shared (system.io_ctx, 24001, nano::unique_path (), system.alarm, system.logging, system.work)); + ASSERT_FALSE (node1->init_error ()); nano::block_hash latest1 (system.nodes[0]->latest (nano::test_genesis_key.pub)); nano::block_hash latest2 (node1->latest (nano::test_genesis_key.pub)); ASSERT_EQ (latest1, latest2); @@ -1103,9 +1085,8 @@ TEST (bulk, offline_send) { nano::system system (24000, 1); system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); - nano::node_init init1; - auto node1 (std::make_shared (init1, system.io_ctx, 24001, nano::unique_path (), system.alarm, system.logging, system.work)); - ASSERT_FALSE (init1.error ()); + auto node1 (std::make_shared (system.io_ctx, 24001, nano::unique_path (), system.alarm, system.logging, system.work)); + ASSERT_FALSE (node1->init_error ()); node1->start (); system.nodes.push_back (node1); nano::keypair key2; @@ -2331,8 +2312,7 @@ TEST (network, replace_port) { nano::system system (24000, 1); ASSERT_EQ (0, system.nodes[0]->network.size ()); - nano::node_init init1; - auto node1 (std::make_shared (init1, system.io_ctx, 24001, nano::unique_path (), system.alarm, system.logging, system.work)); + auto node1 (std::make_shared (system.io_ctx, 24001, nano::unique_path (), system.alarm, system.logging, system.work)); node1->start (); system.nodes.push_back (node1); { diff --git a/nano/core_test/node.cpp b/nano/core_test/node.cpp index 37810dc3..f1831c64 100644 --- a/nano/core_test/node.cpp +++ b/nano/core_test/node.cpp @@ -29,21 +29,19 @@ TEST (node, stop) TEST (node, block_store_path_failure) { - nano::node_init init; auto service (boost::make_shared ()); nano::alarm alarm (*service); auto path (nano::unique_path ()); nano::logging logging; logging.init (path); nano::work_pool work (std::numeric_limits::max ()); - auto node (std::make_shared (init, *service, 24000, path, alarm, logging, work)); + auto node (std::make_shared (*service, 24000, path, alarm, logging, work)); ASSERT_TRUE (node->wallets.items.empty ()); node->stop (); } TEST (node, password_fanout) { - nano::node_init init; auto service (boost::make_shared ()); nano::alarm alarm (*service); auto path (nano::unique_path ()); @@ -52,7 +50,7 @@ TEST (node, password_fanout) config.logging.init (path); nano::work_pool work (std::numeric_limits::max ()); config.password_fanout = 10; - auto node (std::make_shared (init, *service, path, alarm, config, work)); + auto node (std::make_shared (*service, path, alarm, config, work)); auto wallet (node->wallets.create (100)); ASSERT_EQ (10, wallet->store.password.values.size ()); node->stop (); @@ -235,9 +233,8 @@ TEST (node, auto_bootstrap) { ASSERT_NO_ERROR (system.poll ()); } - nano::node_init init1; - auto node1 (std::make_shared (init1, system.io_ctx, 24001, nano::unique_path (), system.alarm, system.logging, system.work)); - ASSERT_FALSE (init1.error ()); + auto node1 (std::make_shared (system.io_ctx, 24001, nano::unique_path (), system.alarm, system.logging, system.work)); + ASSERT_FALSE (node1->init_error ()); auto channel (std::make_shared (node1->network.udp_channels, system.nodes[0]->network.endpoint (), node1->network_params.protocol.protocol_version)); node1->network.send_keepalive (channel); node1->start (); @@ -272,9 +269,8 @@ TEST (node, auto_bootstrap_reverse) nano::keypair key2; system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); system.wallet (0)->insert_adhoc (key2.prv); - nano::node_init init1; - auto node1 (std::make_shared (init1, system.io_ctx, 24001, nano::unique_path (), system.alarm, system.logging, system.work)); - ASSERT_FALSE (init1.error ()); + auto node1 (std::make_shared (system.io_ctx, 24001, nano::unique_path (), system.alarm, system.logging, system.work)); + ASSERT_FALSE (node1->init_error ()); ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::test_genesis_key.pub, key2.pub, system.nodes[0]->config.receive_minimum.number ())); auto channel (std::make_shared (system.nodes[0]->network.udp_channels, node1->network.endpoint (), system.nodes[0]->network_params.protocol.protocol_version)); system.nodes[0]->network.send_keepalive (channel); @@ -452,8 +448,7 @@ TEST (node, unlock_search) TEST (node, connect_after_junk) { nano::system system (24000, 1); - nano::node_init init1; - auto node1 (std::make_shared (init1, system.io_ctx, 24001, nano::unique_path (), system.alarm, system.logging, system.work)); + auto node1 (std::make_shared (system.io_ctx, 24001, nano::unique_path (), system.alarm, system.logging, system.work)); auto junk_buffer (std::make_shared> ()); junk_buffer->push_back (0); auto channel1 (std::make_shared (node1->network.udp_channels, system.nodes[0]->network.endpoint (), node1->network_params.protocol.protocol_version)); @@ -1085,8 +1080,7 @@ TEST (node_flags, disable_udp) auto node1 = system.nodes[0]; nano::node_flags node_flags; node_flags.disable_udp = true; - nano::node_init init; - auto node2 (std::make_shared (init, system.io_ctx, nano::unique_path (), system.alarm, nano::node_config (24001, system.logging), system.work, node_flags)); + auto node2 (std::make_shared (system.io_ctx, nano::unique_path (), system.alarm, nano::node_config (24001, system.logging), system.work, node_flags)); system.nodes.push_back (node2); node2->start (); // Send UDP message @@ -2016,8 +2010,7 @@ TEST (node, rep_remove) node.rep_crawler.response (channel1, nano::test_genesis_key.pub, nano::genesis_amount); ASSERT_EQ (2, node.rep_crawler.representative_count ()); // Add inactive TCP representative channel - nano::node_init init; - auto node2 (std::make_shared (init, system.io_ctx, nano::unique_path (), system.alarm, nano::node_config (24003, system.logging), system.work)); + auto node2 (std::make_shared (system.io_ctx, nano::unique_path (), system.alarm, nano::node_config (24003, system.logging), system.work)); std::atomic done{ false }; std::weak_ptr node_w (node.shared ()); node.network.tcp_channels.start_tcp (node2->network.endpoint (), [node_w, &done](std::shared_ptr channel2) { @@ -2904,8 +2897,7 @@ TEST (node, peers) nano::system system (24000, 1); ASSERT_TRUE (system.nodes.front ()->network.empty ()); - nano::node_init init; - auto node (std::make_shared (init, system.io_ctx, 24001, nano::unique_path (), system.alarm, system.logging, system.work)); + auto node (std::make_shared (system.io_ctx, 24001, nano::unique_path (), system.alarm, system.logging, system.work)); system.nodes.push_back (node); auto endpoint = system.nodes.front ()->network.endpoint (); @@ -2968,8 +2960,7 @@ TEST (node, peer_cache_restart) nano::endpoint_key endpoint_key{ endpoint.address ().to_v6 ().to_bytes (), endpoint.port () }; auto path (nano::unique_path ()); { - nano::node_init init; - auto node (std::make_shared (init, system.io_ctx, 24001, path, system.alarm, system.logging, system.work)); + auto node (std::make_shared (system.io_ctx, 24001, path, system.alarm, system.logging, system.work)); system.nodes.push_back (node); auto & store = node->store; { @@ -2991,10 +2982,9 @@ TEST (node, peer_cache_restart) } // Restart node { - nano::node_init init; nano::node_flags node_flags; node_flags.read_only = true; - auto node (std::make_shared (init, system.io_ctx, 24002, path, system.alarm, system.logging, system.work, node_flags)); + auto node (std::make_shared (system.io_ctx, 24002, path, system.alarm, system.logging, system.work, node_flags)); system.nodes.push_back (node); // Check cached peers after restart node->network.start (); @@ -3059,12 +3049,12 @@ TEST (node, dont_write_lock_node) // clang-format off std::thread ([&path, &write_lock_held_promise, &finished_promise]() { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, path, false, true); - nano::genesis genesis; + auto store = nano::make_store (logger, path, false, true); { + nano::genesis genesis; + nano::rep_weights rep_weights; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, rep_weights); } // Hold write lock open until main thread is done needing it diff --git a/nano/core_test/processor_service.cpp b/nano/core_test/processor_service.cpp index 379e836f..db0d0c7a 100644 --- a/nano/core_test/processor_service.cpp +++ b/nano/core_test/processor_service.cpp @@ -11,14 +11,13 @@ TEST (processor_service, bad_send_signature) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_FALSE (init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_FALSE (store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); nano::account_info info1; ASSERT_FALSE (store->account_get (transaction, nano::test_genesis_key.pub, info1)); @@ -31,14 +30,13 @@ TEST (processor_service, bad_send_signature) TEST (processor_service, bad_receive_signature) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_FALSE (init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_FALSE (store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); nano::account_info info1; ASSERT_FALSE (store->account_get (transaction, nano::test_genesis_key.pub, info1)); diff --git a/nano/core_test/versioning.cpp b/nano/core_test/versioning.cpp index beaa8d03..60f7d83c 100644 --- a/nano/core_test/versioning.cpp +++ b/nano/core_test/versioning.cpp @@ -13,9 +13,8 @@ TEST (versioning, account_info_v1) nano::account_info_v1 v1 (open.hash (), open.hash (), 3, 4); { nano::logger_mt logger; - auto error (false); - nano::mdb_store store (error, logger, file); - ASSERT_FALSE (error); + nano::mdb_store store (logger, file); + ASSERT_FALSE (store.init_error ()); auto transaction (store.tx_begin_write ()); nano::block_sideband sideband (nano::block_type::open, 0, 0, 0, 0, 0); store.block_put (transaction, open.hash (), open, sideband); @@ -25,9 +24,8 @@ TEST (versioning, account_info_v1) } nano::logger_mt logger; - auto error (false); - nano::mdb_store store (error, logger, file); - ASSERT_FALSE (error); + nano::mdb_store store (logger, file); + ASSERT_FALSE (store.init_error ()); auto transaction (store.tx_begin_read ()); nano::account_info v_latest; ASSERT_FALSE (store.account_get (transaction, account, v_latest)); @@ -51,9 +49,8 @@ TEST (versioning, account_info_v5) nano::account_info_v5 v5 (open.hash (), open.hash (), open.hash (), 3, 4); { nano::logger_mt logger; - auto error (false); - nano::mdb_store store (error, logger, file); - ASSERT_FALSE (error); + nano::mdb_store store (logger, file); + ASSERT_FALSE (store.init_error ()); auto transaction (store.tx_begin_write ()); nano::block_sideband sideband (nano::block_type::open, 0, 0, 0, 0, 0); store.block_put (transaction, open.hash (), open, sideband); @@ -63,9 +60,8 @@ TEST (versioning, account_info_v5) } nano::logger_mt logger; - auto error (false); - nano::mdb_store store (error, logger, file); - ASSERT_FALSE (error); + nano::mdb_store store (logger, file); + ASSERT_FALSE (store.init_error ()); auto transaction (store.tx_begin_read ()); nano::account_info v_latest; ASSERT_FALSE (store.account_get (transaction, account, v_latest)); @@ -89,9 +85,8 @@ TEST (versioning, account_info_v13) nano::account_info_v13 v13 (open.hash (), open.hash (), open.hash (), 3, 4, 10, nano::epoch::epoch_0); { nano::logger_mt logger; - auto error (false); - nano::mdb_store store (error, logger, file); - ASSERT_FALSE (error); + nano::mdb_store store (logger, file); + ASSERT_FALSE (store.init_error ()); auto transaction (store.tx_begin_write ()); nano::block_sideband sideband (nano::block_type::open, 0, 0, 0, 0, 0); store.block_put (transaction, open.hash (), open, sideband); @@ -101,9 +96,8 @@ TEST (versioning, account_info_v13) } nano::logger_mt logger; - auto error (false); - nano::mdb_store store (error, logger, file); - ASSERT_FALSE (error); + nano::mdb_store store (logger, file); + ASSERT_FALSE (store.init_error ()); auto transaction (store.tx_begin_read ()); nano::account_info v_latest; ASSERT_FALSE (store.account_get (transaction, account, v_latest)); diff --git a/nano/core_test/wallet.cpp b/nano/core_test/wallet.cpp index 9704c695..b128e43e 100644 --- a/nano/core_test/wallet.cpp +++ b/nano/core_test/wallet.cpp @@ -886,9 +886,8 @@ TEST (wallet, upgrade_backup) nano::keypair id; { - nano::node_init init1; - auto node1 (std::make_shared (init1, system.io_ctx, 24001, dir, system.alarm, system.logging, system.work)); - ASSERT_FALSE (init1.error ()); + auto node1 (std::make_shared (system.io_ctx, 24001, dir, system.alarm, system.logging, system.work)); + ASSERT_FALSE (node1->init_error ()); auto wallet (node1->wallets.create (id.pub)); ASSERT_NE (nullptr, wallet); auto transaction (node1->wallets.tx_begin_write ()); @@ -898,13 +897,12 @@ TEST (wallet, upgrade_backup) // Check with config backup_before_upgrade = false { - nano::node_init init1; - auto node1 (std::make_shared (init1, system.io_ctx, 24001, dir, system.alarm, system.logging, system.work)); - ASSERT_FALSE (init1.error ()); + auto node1 (std::make_shared (system.io_ctx, 24001, dir, system.alarm, system.logging, system.work)); + ASSERT_FALSE (node1->init_error ()); auto wallet (node1->wallets.open (id.pub)); ASSERT_NE (nullptr, wallet); auto transaction (node1->wallets.tx_begin_write ()); - ASSERT_LT (3, wallet->store.version (transaction)); + ASSERT_LT (3u, wallet->store.version (transaction)); wallet->store.version_put (transaction, 3); } ASSERT_EQ (get_backup_path ().string (), dir.string ()); @@ -913,13 +911,12 @@ TEST (wallet, upgrade_backup) { nano::node_config node_config (24001, system.logging); node_config.backup_before_upgrade = true; - nano::node_init init1; - auto node1 (std::make_shared (init1, system.io_ctx, dir, system.alarm, node_config, system.work)); - ASSERT_FALSE (init1.error ()); + auto node1 (std::make_shared (system.io_ctx, dir, system.alarm, node_config, system.work)); + ASSERT_FALSE (node1->init_error ()); auto wallet (node1->wallets.open (id.pub)); ASSERT_NE (nullptr, wallet); auto transaction (node1->wallets.tx_begin_read ()); - ASSERT_LT (3, wallet->store.version (transaction)); + ASSERT_LT (3u, wallet->store.version (transaction)); } ASSERT_NE (get_backup_path ().string (), dir.string ()); } diff --git a/nano/core_test/wallets.cpp b/nano/core_test/wallets.cpp index ef727e7f..5b1de95f 100644 --- a/nano/core_test/wallets.cpp +++ b/nano/core_test/wallets.cpp @@ -85,9 +85,8 @@ TEST (wallets, upgrade) auto path (nano::unique_path ()); nano::keypair id; { - nano::node_init init1; - auto node1 (std::make_shared (init1, system.io_ctx, 24001, path, system.alarm, system.logging, system.work)); - ASSERT_FALSE (init1.error ()); + auto node1 (std::make_shared (system.io_ctx, 24001, path, system.alarm, system.logging, system.work)); + ASSERT_FALSE (node1->init_error ()); bool error (false); nano::wallets wallets (error, *node1); wallets.create (id.pub); @@ -106,8 +105,7 @@ TEST (wallets, upgrade) (void)status; assert (status == 0); } - nano::node_init init1; - auto node1 (std::make_shared (init1, system.io_ctx, 24001, path, system.alarm, system.logging, system.work)); + auto node1 (std::make_shared (system.io_ctx, 24001, path, system.alarm, system.logging, system.work)); ASSERT_EQ (1, node1->wallets.items.size ()); ASSERT_EQ (id.pub, node1->wallets.items.begin ()->first); auto transaction_new (node1->wallets.env.tx_begin_write ()); diff --git a/nano/core_test/websocket.cpp b/nano/core_test/websocket.cpp index 9b3bbbed..9a9f7365 100644 --- a/nano/core_test/websocket.cpp +++ b/nano/core_test/websocket.cpp @@ -82,13 +82,12 @@ boost::optional websocket_test_call (std::string host, std::string TEST (websocket, subscription_edge) { nano::system system (24000, 1); - nano::node_init init1; nano::node_config config; nano::node_flags node_flags; config.websocket_config.enabled = true; config.websocket_config.port = 24078; - auto node1 (std::make_shared (init1, system.io_ctx, nano::unique_path (), system.alarm, config, system.work, node_flags)); + auto node1 (std::make_shared (system.io_ctx, nano::unique_path (), system.alarm, config, system.work, node_flags)); node1->start (); system.nodes.push_back (node1); @@ -161,13 +160,12 @@ TEST (websocket, subscription_edge) TEST (websocket, active_difficulty) { nano::system system (24000, 1); - nano::node_init init1; nano::node_config config; nano::node_flags node_flags; config.websocket_config.enabled = true; config.websocket_config.port = 24078; - auto node1 (std::make_shared (init1, system.io_ctx, nano::unique_path (), system.alarm, config, system.work, node_flags)); + auto node1 (std::make_shared (system.io_ctx, nano::unique_path (), system.alarm, config, system.work, node_flags)); node1->start (); system.nodes.push_back (node1); @@ -230,13 +228,12 @@ TEST (websocket, active_difficulty) TEST (websocket, confirmation) { nano::system system (24000, 1); - nano::node_init init1; nano::node_config config; nano::node_flags node_flags; config.websocket_config.enabled = true; config.websocket_config.port = 24078; - auto node1 (std::make_shared (init1, system.io_ctx, nano::unique_path (), system.alarm, config, system.work, node_flags)); + auto node1 (std::make_shared (system.io_ctx, nano::unique_path (), system.alarm, config, system.work, node_flags)); nano::uint256_union wallet; nano::random_pool::generate_block (wallet.bytes.data (), wallet.bytes.size ()); node1->wallets.create (wallet); @@ -341,13 +338,12 @@ TEST (websocket, confirmation) TEST (websocket, stopped_election) { nano::system system (24000, 1); - nano::node_init init1; nano::node_config config; nano::node_flags node_flags; config.websocket_config.enabled = true; config.websocket_config.port = 24078; - auto node1 (std::make_shared (init1, system.io_ctx, nano::unique_path (), system.alarm, config, system.work, node_flags)); + auto node1 (std::make_shared (system.io_ctx, nano::unique_path (), system.alarm, config, system.work, node_flags)); nano::uint256_union wallet; nano::random_pool::generate_block (wallet.bytes.data (), wallet.bytes.size ()); node1->wallets.create (wallet); @@ -404,13 +400,12 @@ TEST (websocket, stopped_election) TEST (websocket, confirmation_options) { nano::system system (24000, 1); - nano::node_init init1; nano::node_config config; nano::node_flags node_flags; config.websocket_config.enabled = true; config.websocket_config.port = 24078; - auto node1 (std::make_shared (init1, system.io_ctx, nano::unique_path (), system.alarm, config, system.work, node_flags)); + auto node1 (std::make_shared (system.io_ctx, nano::unique_path (), system.alarm, config, system.work, node_flags)); nano::uint256_union wallet; nano::random_pool::generate_block (wallet.bytes.data (), wallet.bytes.size ()); node1->wallets.create (wallet); @@ -554,13 +549,12 @@ TEST (websocket, confirmation_options) TEST (websocket, vote) { nano::system system (24000, 1); - nano::node_init init1; nano::node_config config; nano::node_flags node_flags; config.websocket_config.enabled = true; config.websocket_config.port = 24078; - auto node1 (std::make_shared (init1, system.io_ctx, nano::unique_path (), system.alarm, config, system.work, node_flags)); + auto node1 (std::make_shared (system.io_ctx, nano::unique_path (), system.alarm, config, system.work, node_flags)); nano::uint256_union wallet; nano::random_pool::generate_block (wallet.bytes.data (), wallet.bytes.size ()); node1->wallets.create (wallet); @@ -618,13 +612,12 @@ TEST (websocket, vote) TEST (websocket, vote_options) { nano::system system (24000, 1); - nano::node_init init1; nano::node_config config; nano::node_flags node_flags; config.websocket_config.enabled = true; config.websocket_config.port = 24078; - auto node1 (std::make_shared (init1, system.io_ctx, nano::unique_path (), system.alarm, config, system.work, node_flags)); + auto node1 (std::make_shared (system.io_ctx, nano::unique_path (), system.alarm, config, system.work, node_flags)); nano::uint256_union wallet; nano::random_pool::generate_block (wallet.bytes.data (), wallet.bytes.size ()); node1->wallets.create (wallet); diff --git a/nano/lib/CMakeLists.txt b/nano/lib/CMakeLists.txt index 1f146a0b..c6832ac7 100644 --- a/nano/lib/CMakeLists.txt +++ b/nano/lib/CMakeLists.txt @@ -36,6 +36,8 @@ add_library (nano_lib memory.cpp numbers.hpp numbers.cpp + rep_weights.hpp + rep_weights.cpp rpc_handler_interface.hpp rpcconfig.hpp rpcconfig.cpp diff --git a/nano/lib/rep_weights.cpp b/nano/lib/rep_weights.cpp new file mode 100644 index 00000000..734ce075 --- /dev/null +++ b/nano/lib/rep_weights.cpp @@ -0,0 +1,69 @@ +#include +#include + +void nano::rep_weights::representation_add (nano::account const & source_rep, nano::uint128_t const & amount_a) +{ + std::lock_guard guard (mutex); + auto source_previous (get (source_rep)); + put (source_rep, source_previous + amount_a); +} + +void nano::rep_weights::representation_put (nano::account const & account_a, nano::uint128_union const & representation_a) +{ + std::lock_guard guard (mutex); + put (account_a, representation_a); +} + +nano::uint128_t nano::rep_weights::representation_get (nano::account const & account_a) +{ + std::lock_guard lk (mutex); + return get (account_a); +} + +/** Makes a copy */ +std::unordered_map nano::rep_weights::get_rep_amounts () +{ + std::lock_guard guard (mutex); + return rep_amounts; +} + +void nano::rep_weights::put (nano::account const & account_a, nano::uint128_union const & representation_a) +{ + auto it = rep_amounts.find (account_a); + auto amount = representation_a.number (); + if (it != rep_amounts.end ()) + { + it->second = amount; + } + else + { + rep_amounts.emplace (account_a, amount); + } +} + +nano::uint128_t nano::rep_weights::get (nano::account const & account_a) +{ + auto it = rep_amounts.find (account_a); + if (it != rep_amounts.end ()) + { + return it->second; + } + else + { + return nano::uint128_t{ 0 }; + } +} + +std::unique_ptr nano::collect_seq_con_info (nano::rep_weights & rep_weights, const std::string & name) +{ + size_t rep_amounts_count = 0; + + { + std::lock_guard guard (rep_weights.mutex); + rep_amounts_count = rep_weights.rep_amounts.size (); + } + auto sizeof_element = sizeof (decltype (rep_weights.rep_amounts)::value_type); + auto composite = std::make_unique (name); + composite->add_component (std::make_unique (seq_con_info{ "rep_amounts", rep_amounts_count, sizeof_element })); + return composite; +} diff --git a/nano/lib/rep_weights.hpp b/nano/lib/rep_weights.hpp new file mode 100644 index 00000000..b7ad4d7c --- /dev/null +++ b/nano/lib/rep_weights.hpp @@ -0,0 +1,33 @@ +#pragma once + +#include +#include + +#include +#include +#include + +namespace nano +{ +class block_store; +class transaction; + +class rep_weights +{ +public: + void representation_add (nano::account const & source_a, nano::uint128_t const & amount_a); + nano::uint128_t representation_get (nano::account const & account_a); + void representation_put (nano::account const & account_a, nano::uint128_union const & representation_a); + std::unordered_map get_rep_amounts (); + +private: + std::mutex mutex; + std::unordered_map rep_amounts; + void put (nano::account const & account_a, nano::uint128_union const & representation_a); + nano::uint128_t get (nano::account const & account_a); + + friend std::unique_ptr collect_seq_con_info (rep_weights &, const std::string &); +}; + +std::unique_ptr collect_seq_con_info (rep_weights &, const std::string &); +} diff --git a/nano/nano_node/daemon.cpp b/nano/nano_node/daemon.cpp index 1a4e9725..6f81f19a 100644 --- a/nano/nano_node/daemon.cpp +++ b/nano/nano_node/daemon.cpp @@ -54,11 +54,10 @@ void nano_daemon::daemon::run (boost::filesystem::path const & data_path, nano:: } : std::function (nano::uint256_union const &, uint64_t, std::atomic &)> (nullptr)); nano::alarm alarm (io_ctx); - nano::node_init init; try { - auto node (std::make_shared (init, io_ctx, data_path, alarm, config.node, opencl_work, flags)); - if (!init.error ()) + auto node (std::make_shared (io_ctx, data_path, alarm, config.node, opencl_work, flags)); + if (!node->init_error ()) { auto network_label = node->network_params.network.get_current_network_as_string (); std::cout << "Network: " << network_label << ", version: " << NANO_VERSION_STRING << "\n" diff --git a/nano/nano_node/entry.cpp b/nano/nano_node/entry.cpp index aa14d4d4..b99425d9 100644 --- a/nano/nano_node/entry.cpp +++ b/nano/nano_node/entry.cpp @@ -270,29 +270,15 @@ int main (int argc, char * const * argv) } else if (vm.count ("debug_dump_representatives")) { - nano::inactive_node node (data_path); + nano::inactive_node node (data_path, 24000, true); auto transaction (node.node->store.tx_begin_read ()); nano::uint128_t total; - for (auto i (node.node->store.representation_begin (transaction)), n (node.node->store.representation_end ()); i != n; ++i) + auto rep_amounts = node.node->ledger.rep_weights.get_rep_amounts (); + std::map ordered_reps (rep_amounts.begin (), rep_amounts.end ()); + for (auto const & rep : ordered_reps) { - nano::account const & account (i->first); - auto amount (node.node->store.representation_get (transaction, account)); - total += amount; - std::cout << boost::str (boost::format ("%1% %2% %3%\n") % account.to_account () % amount.convert_to () % total.convert_to ()); - } - std::map calculated; - for (auto i (node.node->store.latest_begin (transaction)), n (node.node->store.latest_end ()); i != n; ++i) - { - nano::account_info const & info (i->second); - nano::block_hash rep_block (node.node->ledger.representative_calculated (transaction, info.head)); - auto block (node.node->store.block_get (transaction, rep_block)); - calculated[block->representative ()] += info.balance.number (); - } - total = 0; - for (auto i (calculated.begin ()), n (calculated.end ()); i != n; ++i) - { - total += i->second; - std::cout << boost::str (boost::format ("%1% %2% %3%\n") % i->first.to_account () % i->second.convert_to () % total.convert_to ()); + total += rep.second; + std::cout << boost::str (boost::format ("%1% %2% %3%\n") % rep.first.to_account () % rep.second.convert_to () % total.convert_to ()); } } else if (vm.count ("debug_dump_frontier_unchecked_dependents")) @@ -565,12 +551,11 @@ int main (int argc, char * const * argv) size_t max_blocks (2 * num_accounts * num_interations + num_accounts * 2); // 1,000,000 + 2* 100,000 = 1,200,000 blocks std::cerr << boost::str (boost::format ("Starting pregenerating %1% blocks\n") % max_blocks); nano::system system (24000, 1); - nano::node_init init; nano::work_pool work (std::numeric_limits::max ()); nano::logging logging; auto path (nano::unique_path ()); logging.init (path); - auto node (std::make_shared (init, system.io_ctx, 24001, path, system.alarm, logging, work)); + auto node (std::make_shared (system.io_ctx, 24001, path, system.alarm, logging, work)); nano::block_hash genesis_latest (node->latest (test_params.ledger.test_genesis_key.pub)); nano::uint128_t genesis_balance (std::numeric_limits::max ()); // Generating keys @@ -677,12 +662,11 @@ int main (int argc, char * const * argv) size_t max_votes (num_elections * num_representatives); // 40,000 * 25 = 1,000,000 votes std::cerr << boost::str (boost::format ("Starting pregenerating %1% votes\n") % max_votes); nano::system system (24000, 1); - nano::node_init init; nano::work_pool work (std::numeric_limits::max ()); nano::logging logging; auto path (nano::unique_path ()); logging.init (path); - auto node (std::make_shared (init, system.io_ctx, 24001, path, system.alarm, logging, work)); + auto node (std::make_shared (system.io_ctx, 24001, path, system.alarm, logging, work)); nano::block_hash genesis_latest (node->latest (test_params.ledger.test_genesis_key.pub)); nano::uint128_t genesis_balance (std::numeric_limits::max ()); // Generating keys diff --git a/nano/nano_wallet/entry.cpp b/nano/nano_wallet/entry.cpp index ae8cef4c..13ce90a5 100644 --- a/nano/nano_wallet/entry.cpp +++ b/nano/nano_wallet/entry.cpp @@ -85,11 +85,10 @@ int run_wallet (QApplication & application, int argc, char * const * argv, boost } : std::function (nano::uint256_union const &, uint64_t, std::atomic &)> (nullptr)); nano::alarm alarm (io_ctx); - nano::node_init init; nano::node_flags flags; - node = std::make_shared (init, io_ctx, data_path, alarm, config.node, work, flags); - if (!init.error ()) + node = std::make_shared (io_ctx, data_path, alarm, config.node, work, flags); + if (!node->init_error ()) { auto wallet (node->wallets.open (wallet_config.wallet)); if (wallet == nullptr) diff --git a/nano/node/cli.cpp b/nano/node/cli.cpp index 9a83602e..9dc5bcf8 100644 --- a/nano/node/cli.cpp +++ b/nano/node/cli.cpp @@ -84,7 +84,7 @@ bool copy_database (boost::filesystem::path const & data_path, boost::program_op bool needs_to_write = vm.count ("unchecked_clear") || vm.count ("clear_send_ids") || vm.count ("online_weight_clear") || vm.count ("peer_clear") || vm.count ("confirmation_height_clear"); nano::inactive_node node (data_path, 24000, !needs_to_write); - if (!node.init.error ()) + if (!node.node->init_error ()) { if (vm.count ("unchecked_clear")) { @@ -291,7 +291,7 @@ std::error_code nano::handle_node_options (boost::program_options::variables_map { boost::filesystem::path data_path = vm.count ("data_path") ? boost::filesystem::path (vm["data_path"].as ()) : nano::working_path (); inactive_node node (data_path, 24000, false); - if (!node.init.error ()) + if (!node.node->init_error ()) { auto transaction (node.node->store.tx_begin_write ()); node.node->store.unchecked_clear (transaction); @@ -306,7 +306,7 @@ std::error_code nano::handle_node_options (boost::program_options::variables_map { boost::filesystem::path data_path = vm.count ("data_path") ? boost::filesystem::path (vm["data_path"].as ()) : nano::working_path (); inactive_node node (data_path, 24000, false); - if (!node.init.error ()) + if (!node.node->init_error ()) { auto transaction (node.node->wallets.tx_begin_write ()); node.node->wallets.clear_send_ids (transaction); @@ -321,7 +321,7 @@ std::error_code nano::handle_node_options (boost::program_options::variables_map { boost::filesystem::path data_path = vm.count ("data_path") ? boost::filesystem::path (vm["data_path"].as ()) : nano::working_path (); inactive_node node (data_path, 24000, false); - if (!node.init.error ()) + if (!node.node->init_error ()) { auto transaction (node.node->store.tx_begin_write ()); node.node->store.online_weight_clear (transaction); @@ -336,7 +336,7 @@ std::error_code nano::handle_node_options (boost::program_options::variables_map { boost::filesystem::path data_path = vm.count ("data_path") ? boost::filesystem::path (vm["data_path"].as ()) : nano::working_path (); inactive_node node (data_path, 24000, false); - if (!node.init.error ()) + if (!node.node->init_error ()) { auto transaction (node.node->store.tx_begin_write ()); node.node->store.peer_clear (transaction); @@ -351,7 +351,7 @@ std::error_code nano::handle_node_options (boost::program_options::variables_map { boost::filesystem::path data_path = vm.count ("data_path") ? boost::filesystem::path (vm["data_path"].as ()) : nano::working_path (); inactive_node node (data_path, 24000, false); - if (!node.init.error ()) + if (!node.node->init_error ()) { auto account_it = vm.find ("account"); if (account_it != vm.cend ()) diff --git a/nano/node/json_handler.cpp b/nano/node/json_handler.cpp index a1e9d9d0..316b0cca 100644 --- a/nano/node/json_handler.cpp +++ b/nano/node/json_handler.cpp @@ -1799,7 +1799,7 @@ void nano::json_handler::confirmation_info () if (i->second->hash () == ii->second.hash) { nano::account const & representative (ii->first); - auto amount (node.store.representation_get (transaction, representative)); + auto amount (node.ledger.rep_weights.representation_get (representative)); representatives.emplace (std::move (amount), representative); } } @@ -3131,30 +3131,37 @@ void nano::json_handler::representatives () { const bool sorting = request.get ("sorting", false); boost::property_tree::ptree representatives; - auto transaction (node.store.tx_begin_read ()); + auto rep_amounts = node.ledger.rep_weights.get_rep_amounts (); if (!sorting) // Simple { - for (auto i (node.store.representation_begin (transaction)), n (node.store.representation_end ()); i != n && representatives.size () < count; ++i) + std::map ordered (rep_amounts.begin (), rep_amounts.end ()); + for (auto & rep_amount : rep_amounts) { - nano::account const & account (i->first); - auto amount (node.store.representation_get (transaction, account)); + auto const & account (rep_amount.first); + auto const & amount (rep_amount.second); representatives.put (account.to_account (), amount.convert_to ()); + + if (representatives.size () > count) + { + break; + } } } else // Sorting { - std::vector> representation; - for (auto i (node.store.representation_begin (transaction)), n (node.store.representation_end ()); i != n; ++i) + std::vector> representation; + + for (auto & rep_amount : rep_amounts) { - nano::account const & account (i->first); - auto amount (node.store.representation_get (transaction, account)); - representation.push_back (std::make_pair (amount, account.to_account ())); + auto const & account (rep_amount.first); + auto const & amount (rep_amount.second); + representation.emplace_back (amount, account.to_account ()); } std::sort (representation.begin (), representation.end ()); std::reverse (representation.begin (), representation.end ()); for (auto i (representation.begin ()), n (representation.end ()); i != n && representatives.size () < count; ++i) { - representatives.put (i->second, (i->first).number ().convert_to ()); + representatives.put (i->second, (i->first).convert_to ()); } } response_l.add_child ("representatives", representatives); diff --git a/nano/node/lmdb/lmdb.cpp b/nano/node/lmdb/lmdb.cpp index ba40a66d..4bbab271 100644 --- a/nano/node/lmdb/lmdb.cpp +++ b/nano/node/lmdb/lmdb.cpp @@ -39,13 +39,13 @@ void mdb_val::convert_buffer_to_value () } } -nano::mdb_store::mdb_store (bool & error_a, nano::logger_mt & logger_a, boost::filesystem::path const & path_a, nano::txn_tracking_config const & txn_tracking_config_a, std::chrono::milliseconds block_processor_batch_max_time_a, int lmdb_max_dbs, bool drop_unchecked, size_t const batch_size, bool backup_before_upgrade) : +nano::mdb_store::mdb_store (nano::logger_mt & logger_a, boost::filesystem::path const & path_a, nano::txn_tracking_config const & txn_tracking_config_a, std::chrono::milliseconds block_processor_batch_max_time_a, int lmdb_max_dbs, bool drop_unchecked, size_t const batch_size, bool backup_before_upgrade) : logger (logger_a), -env (error_a, path_a, lmdb_max_dbs, true), +env (error, path_a, lmdb_max_dbs, true), mdb_txn_tracker (logger_a, txn_tracking_config_a, block_processor_batch_max_time_a), txn_tracking_enabled (txn_tracking_config_a.enable) { - if (!error_a) + if (!error) { auto is_fully_upgraded (false); { @@ -68,19 +68,19 @@ txn_tracking_enabled (txn_tracking_config_a.enable) create_backup_file (env, path_a, logger_a); } auto transaction (tx_begin_write ()); - open_databases (error_a, transaction, MDB_CREATE); - if (!error_a) + open_databases (error, transaction, MDB_CREATE); + if (!error) { - error_a |= do_upgrades (transaction, batch_size); + error |= do_upgrades (transaction, batch_size); } } else { auto transaction (tx_begin_read ()); - open_databases (error_a, transaction, 0); + open_databases (error, transaction, 0); } - if (!error_a && drop_unchecked) + if (!error && drop_unchecked) { auto transaction (tx_begin_write ({ nano::tables::cached_counts, tables::unchecked })); unchecked_clear (transaction); @@ -133,7 +133,6 @@ void nano::mdb_store::open_databases (bool & error_a, nano::transaction const & error_a |= mdb_dbi_open (env.tx (transaction_a), "state_v1", flags, &state_blocks_v1) != 0; error_a |= mdb_dbi_open (env.tx (transaction_a), "pending", flags, &pending_v0) != 0; error_a |= mdb_dbi_open (env.tx (transaction_a), "pending_v1", flags, &pending_v1) != 0; - error_a |= mdb_dbi_open (env.tx (transaction_a), "representation", flags, &representation) != 0; error_a |= mdb_dbi_open (env.tx (transaction_a), "unchecked", flags, &unchecked) != 0; error_a |= mdb_dbi_open (env.tx (transaction_a), "vote", flags, &vote) != 0; error_a |= mdb_dbi_open (env.tx (transaction_a), "online_weight", flags, &online_weight) != 0; @@ -237,7 +236,6 @@ void nano::mdb_store::upgrade_v2_to_v3 (nano::write_transaction const & transact info.rep_block = visitor.result; auto impl (boost::polymorphic_downcast *> (i.get ())); mdb_cursor_put (impl->cursor, nano::mdb_val (account_l), nano::mdb_val (sizeof (info), &info), MDB_CURRENT); - representation_add (transaction_a, visitor.result, info.balance.number ()); } } @@ -497,6 +495,14 @@ void nano::mdb_store::upgrade_v14_to_v15 (nano::write_transaction const & transa { account_put (transaction_a, account_info.first, account_info.second); } + + // Representation table is no longer used + if (representation != 0) + { + auto status (mdb_drop (env.tx (transaction_a), representation, 1)); + release_assert (status == MDB_SUCCESS); + representation = 0; + } } /** Takes a filepath, appends '_backup_' to the end (but before any extension) and saves that file in the same directory */ @@ -645,8 +651,6 @@ MDB_dbi nano::mdb_store::table_to_dbi (tables table_a) const return pending_v1; case tables::blocks_info: return blocks_info; - case tables::representation: - return representation; case tables::unchecked: return unchecked; case tables::vote: @@ -683,4 +687,9 @@ int nano::mdb_store::status_code_not_found () const bool nano::mdb_store::copy_db (boost::filesystem::path const & destination_file) { return !mdb_env_copy2 (env.environment, destination_file.string ().c_str (), MDB_CP_COMPACT); -} \ No newline at end of file +} + +bool nano::mdb_store::init_error () const +{ + return error; +} diff --git a/nano/node/lmdb/lmdb.hpp b/nano/node/lmdb/lmdb.hpp index 165e6e84..a86d93a8 100644 --- a/nano/node/lmdb/lmdb.hpp +++ b/nano/node/lmdb/lmdb.hpp @@ -32,7 +32,7 @@ public: using block_store_partial::block_exists; using block_store_partial::unchecked_put; - mdb_store (bool &, nano::logger_mt &, boost::filesystem::path const &, nano::txn_tracking_config const & txn_tracking_config_a = nano::txn_tracking_config{}, std::chrono::milliseconds block_processor_batch_max_time_a = std::chrono::milliseconds (5000), int lmdb_max_dbs = 128, bool drop_unchecked = false, size_t batch_size = 512, bool backup_before_upgrade = false); + mdb_store (nano::logger_mt &, boost::filesystem::path const &, nano::txn_tracking_config const & txn_tracking_config_a = nano::txn_tracking_config{}, std::chrono::milliseconds block_processor_batch_max_time_a = std::chrono::milliseconds (5000), int lmdb_max_dbs = 128, bool drop_unchecked = false, size_t batch_size = 512, bool backup_before_upgrade = false); nano::write_transaction tx_begin_write (std::vector const & tables_requiring_lock = {}, std::vector const & tables_no_lock = {}) override; nano::read_transaction tx_begin_read () override; @@ -44,8 +44,11 @@ public: static void create_backup_file (nano::mdb_env &, boost::filesystem::path const &, nano::logger_mt &); +private: nano::logger_mt & logger; + bool error{ false }; +public: nano::mdb_env env; /** @@ -115,13 +118,13 @@ public: MDB_dbi pending_v1{ 0 }; /** - * Maps block hash to account and balance. + * Maps block hash to account and balance. (Removed) * block_hash -> nano::account, nano::amount */ MDB_dbi blocks_info{ 0 }; /** - * Representative weights. + * Representative weights. (Removed) * nano::account -> nano::uint128_t */ MDB_dbi representation{ 0 }; @@ -194,6 +197,8 @@ public: return nano::store_iterator (std::make_unique> (transaction_a, table_to_dbi (table1_a), table_to_dbi (table2_a))); } + bool init_error () const override; + private: bool do_upgrades (nano::write_transaction &, size_t); void upgrade_v1_to_v2 (nano::write_transaction const &); diff --git a/nano/node/node.cpp b/nano/node/node.cpp index 18efaa80..fcee6a6f 100644 --- a/nano/node/node.cpp +++ b/nano/node/node.cpp @@ -64,11 +64,6 @@ void nano::node::keepalive (std::string const & address_a, uint16_t port_a) }); } -bool nano::node_init::error () const -{ - return block_store_init || wallets_store_init; -} - namespace nano { std::unique_ptr collect_seq_con_info (rep_crawler & rep_crawler, const std::string & name) @@ -113,12 +108,12 @@ std::unique_ptr collect_seq_con_info (block_processor & } } -nano::node::node (nano::node_init & init_a, boost::asio::io_context & io_ctx_a, uint16_t peering_port_a, boost::filesystem::path const & application_path_a, nano::alarm & alarm_a, nano::logging const & logging_a, nano::work_pool & work_a, nano::node_flags flags_a) : -node (init_a, io_ctx_a, application_path_a, alarm_a, nano::node_config (peering_port_a, logging_a), work_a, flags_a) +nano::node::node (boost::asio::io_context & io_ctx_a, uint16_t peering_port_a, boost::filesystem::path const & application_path_a, nano::alarm & alarm_a, nano::logging const & logging_a, nano::work_pool & work_a, nano::node_flags flags_a) : +node (io_ctx_a, application_path_a, alarm_a, nano::node_config (peering_port_a, logging_a), work_a, flags_a) { } -nano::node::node (nano::node_init & init_a, boost::asio::io_context & io_ctx_a, boost::filesystem::path const & application_path_a, nano::alarm & alarm_a, nano::node_config const & config_a, nano::work_pool & work_a, nano::node_flags flags_a) : +nano::node::node (boost::asio::io_context & io_ctx_a, boost::filesystem::path const & application_path_a, nano::alarm & alarm_a, nano::node_config const & config_a, nano::work_pool & work_a, nano::node_flags flags_a) : io_ctx (io_ctx_a), node_initialized_latch (1), config (config_a), @@ -127,12 +122,12 @@ flags (flags_a), alarm (alarm_a), work (work_a), logger (config_a.logging.min_time_between_log_output), -store_impl (nano::make_store (init_a.block_store_init, logger, application_path_a, flags.read_only, true, config_a.diagnostics_config.txn_tracking, config_a.block_processor_batch_max_time, config_a.lmdb_max_dbs, !flags.disable_unchecked_drop, flags.sideband_batch_size, config_a.backup_before_upgrade)), +store_impl (nano::make_store (logger, application_path_a, flags.read_only, true, config_a.diagnostics_config.txn_tracking, config_a.block_processor_batch_max_time, config_a.lmdb_max_dbs, !flags.disable_unchecked_drop, flags.sideband_batch_size, config_a.backup_before_upgrade)), store (*store_impl), -wallets_store_impl (std::make_unique (init_a.wallets_store_init, application_path_a / "wallets.ldb", config_a.lmdb_max_dbs)), +wallets_store_impl (std::make_unique (application_path_a / "wallets.ldb", config_a.lmdb_max_dbs)), wallets_store (*wallets_store_impl), gap_cache (*this), -ledger (store, stats, config.epoch_block_link, config.epoch_block_signer), +ledger (store, stats, config.epoch_block_link, config.epoch_block_signer, flags_a.cache_representative_weights_from_frontiers), checker (config.signature_checker_threads), network (*this, config.peering_port), bootstrap_initiator (*this), @@ -147,15 +142,15 @@ block_processor_thread ([this]() { nano::thread_role::set (nano::thread_role::name::block_processing); this->block_processor.process_blocks (); }), -online_reps (*this, config.online_weight_minimum.number (), init_a.block_store_init), +online_reps (*this, config.online_weight_minimum.number ()), vote_uniquer (block_uniquer), active (*this), confirmation_height_processor (pending_confirmation_height, store, ledger.stats, active, ledger.epoch_link, write_database_queue, config.conf_height_processor_batch_min_time, logger), payment_observer_processor (observers.blocks), -wallets (init_a.wallets_store_init, *this), +wallets (wallets_store.init_error (), *this), startup_time (std::chrono::steady_clock::now ()) { - if (!init_a.error ()) + if (!init_error ()) { if (config.websocket_config.enabled) { @@ -396,7 +391,7 @@ startup_time (std::chrono::steady_clock::now ()) release_assert (!flags.read_only); auto transaction (store.tx_begin_write ()); // Store was empty meaning we just created it, add the genesis block - store.initialize (transaction, genesis); + store.initialize (transaction, genesis, ledger.rep_weights); } auto transaction (store.tx_begin_read ()); @@ -1639,7 +1634,12 @@ int nano::node::store_version () return store.version_get (transaction); } -nano::inactive_node::inactive_node (boost::filesystem::path const & path_a, uint16_t peering_port_a, bool read_only_a) : +bool nano::node::init_error () const +{ + return store.init_error () || wallets_store.init_error (); +} + +nano::inactive_node::inactive_node (boost::filesystem::path const & path_a, uint16_t peering_port_a, bool read_only_a, bool cache_reps_a) : path (path_a), io_context (std::make_shared ()), alarm (*io_context), @@ -1655,9 +1655,10 @@ peering_port (peering_port_a) nano::set_secure_perm_directory (path, error_chmod); logging.max_size = std::numeric_limits::max (); logging.init (path); - auto node_flags = nano::node_flags (); + nano::node_flags node_flags; node_flags.read_only = read_only_a; - node = std::make_shared (init, *io_context, peering_port, path, alarm, logging, work, node_flags); + node_flags.cache_representative_weights_from_frontiers = cache_reps_a; + node = std::make_shared (*io_context, peering_port, path, alarm, logging, work, node_flags); node->active.stop (); } @@ -1666,11 +1667,11 @@ nano::inactive_node::~inactive_node () node->stop (); } -std::unique_ptr nano::make_store (bool & init, nano::logger_mt & logger, boost::filesystem::path const & path, bool read_only, bool add_db_postfix, nano::txn_tracking_config const & txn_tracking_config_a, std::chrono::milliseconds block_processor_batch_max_time_a, int lmdb_max_dbs, bool drop_unchecked, size_t batch_size, bool backup_before_upgrade) +std::unique_ptr nano::make_store (nano::logger_mt & logger, boost::filesystem::path const & path, bool read_only, bool add_db_postfix, nano::txn_tracking_config const & txn_tracking_config_a, std::chrono::milliseconds block_processor_batch_max_time_a, int lmdb_max_dbs, bool drop_unchecked, size_t batch_size, bool backup_before_upgrade) { #if NANO_ROCKSDB - return std::make_unique (init, logger, add_db_postfix ? path / "rocksdb" : path, drop_unchecked, read_only); + return std::make_unique (logger, add_db_postfix ? path / "rocksdb" : path, drop_unchecked, read_only); #else - return std::make_unique (init, logger, add_db_postfix ? path / "data.ldb" : path, txn_tracking_config_a, block_processor_batch_max_time_a, lmdb_max_dbs, drop_unchecked, batch_size, backup_before_upgrade); + return std::make_unique (logger, add_db_postfix ? path / "data.ldb" : path, txn_tracking_config_a, block_processor_batch_max_time_a, lmdb_max_dbs, drop_unchecked, batch_size, backup_before_upgrade); #endif } diff --git a/nano/node/node.hpp b/nano/node/node.hpp index d7e9e4c9..f390a469 100644 --- a/nano/node/node.hpp +++ b/nano/node/node.hpp @@ -2,6 +2,7 @@ #include #include +#include #include #include #include @@ -72,22 +73,14 @@ public: std::unique_ptr collect_seq_con_info (block_arrival & block_arrival, const std::string & name); -class node_init final -{ -public: - bool error () const; - bool block_store_init{ false }; - bool wallets_store_init{ false }; -}; - std::unique_ptr collect_seq_con_info (rep_crawler & rep_crawler, const std::string & name); std::unique_ptr collect_seq_con_info (block_processor & block_processor, const std::string & name); class node final : public std::enable_shared_from_this { public: - node (nano::node_init &, boost::asio::io_context &, uint16_t, boost::filesystem::path const &, nano::alarm &, nano::logging const &, nano::work_pool &, nano::node_flags = nano::node_flags ()); - node (nano::node_init &, boost::asio::io_context &, boost::filesystem::path const &, nano::alarm &, nano::node_config const &, nano::work_pool &, nano::node_flags = nano::node_flags ()); + node (boost::asio::io_context &, uint16_t, boost::filesystem::path const &, nano::alarm &, nano::logging const &, nano::work_pool &, nano::node_flags = nano::node_flags ()); + node (boost::asio::io_context &, boost::filesystem::path const &, nano::alarm &, nano::node_config const &, nano::work_pool &, nano::node_flags = nano::node_flags ()); ~node (); template void background (T action_a) @@ -141,6 +134,7 @@ public: void ongoing_online_weight_calculation (); void ongoing_online_weight_calculation_queue (); bool online () const; + bool init_error () const; nano::worker worker; nano::write_database_queue write_database_queue; boost::asio::io_context & io_ctx; @@ -195,13 +189,12 @@ std::unique_ptr collect_seq_con_info (node & node, const class inactive_node final { public: - inactive_node (boost::filesystem::path const & path = nano::working_path (), uint16_t = 24000, bool read_only_a = true); + inactive_node (boost::filesystem::path const & path = nano::working_path (), uint16_t = 24000, bool = true, bool = false); ~inactive_node (); boost::filesystem::path path; std::shared_ptr io_context; nano::alarm alarm; nano::logging logging; - nano::node_init init; nano::work_pool work; uint16_t peering_port; std::shared_ptr node; diff --git a/nano/node/nodeconfig.hpp b/nano/node/nodeconfig.hpp index 020924ce..19fb550f 100644 --- a/nano/node/nodeconfig.hpp +++ b/nano/node/nodeconfig.hpp @@ -117,6 +117,8 @@ public: bool disable_unchecked_drop{ true }; bool fast_bootstrap{ false }; bool read_only{ false }; + /** Whether to read all frontiers and construct the representative weights */ + bool cache_representative_weights_from_frontiers{ true }; size_t sideband_batch_size{ 512 }; size_t block_processor_batch_size{ 0 }; size_t block_processor_full_size{ 65536 }; diff --git a/nano/node/online_reps.cpp b/nano/node/online_reps.cpp index aef598fd..629b783f 100644 --- a/nano/node/online_reps.cpp +++ b/nano/node/online_reps.cpp @@ -3,11 +3,11 @@ #include -nano::online_reps::online_reps (nano::node & node_a, nano::uint128_t minimum_a, bool block_store_error_a) : +nano::online_reps::online_reps (nano::node & node_a, nano::uint128_t minimum_a) : node (node_a), minimum (minimum_a) { - if (!block_store_error_a) + if (!node.ledger.store.init_error ()) { auto transaction (node.ledger.store.tx_begin_read ()); online = trend (transaction); diff --git a/nano/node/online_reps.hpp b/nano/node/online_reps.hpp index 9dc3b5f5..27488bbe 100644 --- a/nano/node/online_reps.hpp +++ b/nano/node/online_reps.hpp @@ -16,7 +16,7 @@ class transaction; class online_reps final { public: - online_reps (nano::node &, nano::uint128_t, bool); + online_reps (nano::node &, nano::uint128_t); /** Add voting account \p rep_account to the set of online representatives */ void observe (nano::account const & rep_account); diff --git a/nano/node/rocksdb/rocksdb.cpp b/nano/node/rocksdb/rocksdb.cpp index f50b006e..f2f0840e 100644 --- a/nano/node/rocksdb/rocksdb.cpp +++ b/nano/node/rocksdb/rocksdb.cpp @@ -40,15 +40,15 @@ void rocksdb_val::convert_buffer_to_value () } } -nano::rocksdb_store::rocksdb_store (bool & error_a, nano::logger_mt & logger_a, boost::filesystem::path const & path_a, bool drop_unchecked_a, bool open_read_only_a) : +nano::rocksdb_store::rocksdb_store (nano::logger_mt & logger_a, boost::filesystem::path const & path_a, bool drop_unchecked_a, bool open_read_only_a) : logger (logger_a) { boost::system::error_code error_mkdir, error_chmod; boost::filesystem::create_directories (path_a, error_mkdir); nano::set_secure_perm_directory (path_a, error_chmod); - error_a |= static_cast (error_mkdir); + error = static_cast (error_mkdir); - if (!error_a) + if (!error) { auto table_options = get_table_options (); table_factory.reset (rocksdb::NewBlockBasedTableFactory (table_options)); @@ -56,10 +56,10 @@ logger (logger_a) { construct_column_family_mutexes (); } - open (error_a, path_a, open_read_only_a); + open (error, path_a, open_read_only_a); } - if (!error_a && !open_read_only_a && drop_unchecked_a) + if (!error && !open_read_only_a && drop_unchecked_a) { auto transaction (tx_begin_write ({ nano::tables::cached_counts, tables::unchecked })); unchecked_clear (transaction); @@ -608,9 +608,13 @@ bool nano::rocksdb_store::copy_db (boost::filesystem::path const & destination_p // Open it so that it flushes all WAL files if (status.ok ()) { - auto error{ false }; - nano::rocksdb_store rocksdb_store (error, logger, destination_path.string (), false, false); - return !error; + nano::rocksdb_store rocksdb_store (logger, destination_path.string (), false, false); + return !rocksdb_store.init_error (); } return false; } + +bool nano::rocksdb_store::init_error () const +{ + return error; +} \ No newline at end of file diff --git a/nano/node/rocksdb/rocksdb.hpp b/nano/node/rocksdb/rocksdb.hpp index 765d5554..09511230 100644 --- a/nano/node/rocksdb/rocksdb.hpp +++ b/nano/node/rocksdb/rocksdb.hpp @@ -24,7 +24,7 @@ class logging_mt; class rocksdb_store : public block_store_partial { public: - rocksdb_store (bool &, nano::logger_mt &, boost::filesystem::path const &, bool drop_unchecked = false, bool open_read_only = false); + rocksdb_store (nano::logger_mt &, boost::filesystem::path const &, bool drop_unchecked = false, bool open_read_only = false); ~rocksdb_store (); nano::write_transaction tx_begin_write (std::vector const & tables_requiring_lock = {}, std::vector const & tables_no_lock = {}) override; nano::read_transaction tx_begin_read () override; @@ -69,7 +69,10 @@ public: return nano::store_iterator (std::make_unique> (db, transaction_a, table_to_column_family (table1_a), table_to_column_family (table2_a))); } + bool init_error () const override; + private: + bool error{ false }; nano::logger_mt & logger; std::vector handles; // Optimistic transactions are used in write mode diff --git a/nano/node/testing.cpp b/nano/node/testing.cpp index 273a5814..1ae8dda1 100644 --- a/nano/node/testing.cpp +++ b/nano/node/testing.cpp @@ -25,9 +25,8 @@ std::string nano::error_system_messages::message (int ev) const /** Returns the node added. */ std::shared_ptr nano::system::add_node (nano::node_config const & node_config_a, nano::node_flags node_flags_a, nano::transport::transport_type type_a) { - nano::node_init init; - auto node (std::make_shared (init, io_ctx, nano::unique_path (), alarm, node_config_a, work, node_flags_a)); - assert (!init.error ()); + auto node (std::make_shared (io_ctx, nano::unique_path (), alarm, node_config_a, work, node_flags_a)); + assert (!node->init_error ()); node->start (); nano::uint256_union wallet; nano::random_pool::generate_block (wallet.bytes.data (), wallet.bytes.size ()); diff --git a/nano/node/vote_processor.cpp b/nano/node/vote_processor.cpp index ba8f4c33..d80cdf94 100644 --- a/nano/node/vote_processor.cpp +++ b/nano/node/vote_processor.cpp @@ -263,9 +263,10 @@ void nano::vote_processor::calculate_weights () representatives_3.clear (); auto supply (node.online_reps.online_stake ()); auto transaction (node.store.tx_begin_read ()); - for (auto i (node.store.representation_begin (transaction)), n (node.store.representation_end ()); i != n; ++i) + auto rep_amounts = node.ledger.rep_weights.get_rep_amounts (); + for (auto const & rep_amount : rep_amounts) { - nano::account const & representative (i->first); + nano::account const & representative (rep_amount.first); auto weight (node.ledger.weight (transaction, representative)); if (weight > supply / 1000) // 0.1% or above (level 1) { diff --git a/nano/node/wallet.cpp b/nano/node/wallet.cpp index 4a21bcb3..221685c9 100644 --- a/nano/node/wallet.cpp +++ b/nano/node/wallet.cpp @@ -1995,10 +1995,16 @@ nano::store_iterator nano::wallet_store { return nano::store_iterator (nullptr); } -nano::mdb_wallets_store::mdb_wallets_store (bool & error_a, boost::filesystem::path const & path_a, int lmdb_max_dbs) : -environment (error_a, path_a, lmdb_max_dbs, false, 1ULL * 1024 * 1024 * 1024) +nano::mdb_wallets_store::mdb_wallets_store (boost::filesystem::path const & path_a, int lmdb_max_dbs) : +environment (error, path_a, lmdb_max_dbs, false, 1ULL * 1024 * 1024 * 1024) { } + +bool nano::mdb_wallets_store::init_error () const +{ + return error; +} + MDB_txn * nano::wallet_store::tx (nano::transaction const & transaction_a) const { return static_cast (transaction_a.get_handle ()); @@ -2020,7 +2026,7 @@ std::unique_ptr collect_seq_con_info (wallets & wallets, auto sizeof_item_element = sizeof (decltype (wallets.items)::value_type); auto sizeof_actions_element = sizeof (decltype (wallets.actions)::value_type); composite->add_component (std::make_unique (seq_con_info{ "items", items_count, sizeof_item_element })); - composite->add_component (std::make_unique (seq_con_info{ "actions_count", actions_count, sizeof_actions_element })); + composite->add_component (std::make_unique (seq_con_info{ "actions", actions_count, sizeof_actions_element })); return composite; } } diff --git a/nano/node/wallet.hpp b/nano/node/wallet.hpp index ded64897..0d014353 100644 --- a/nano/node/wallet.hpp +++ b/nano/node/wallet.hpp @@ -236,11 +236,14 @@ class wallets_store { public: virtual ~wallets_store () = default; + virtual bool init_error () const = 0; }; class mdb_wallets_store final : public wallets_store { public: - mdb_wallets_store (bool &, boost::filesystem::path const &, int lmdb_max_dbs = 128); + mdb_wallets_store (boost::filesystem::path const &, int lmdb_max_dbs = 128); nano::mdb_env environment; + bool init_error () const override; + bool error{ false }; }; } diff --git a/nano/qt_test/qt.cpp b/nano/qt_test/qt.cpp index cc7e694b..77456729 100644 --- a/nano/qt_test/qt.cpp +++ b/nano/qt_test/qt.cpp @@ -465,7 +465,6 @@ TEST (wallet, create_change) TEST (history, short_text) { - bool init (false); nano_qt::eventloop_processor processor; nano::keypair key; nano::system system (24000, 1); @@ -476,13 +475,13 @@ TEST (history, short_text) account = system.account (transaction, 0); } auto wallet (std::make_shared (*test_application, processor, *system.nodes[0], system.wallet (0), account)); - nano::mdb_store store (init, system.nodes[0]->logger, nano::unique_path ()); - ASSERT_TRUE (!init); + nano::mdb_store store (system.nodes[0]->logger, nano::unique_path ()); + ASSERT_TRUE (!store.init_error ()); nano::genesis genesis; nano::ledger ledger (store, system.nodes[0]->stats); { auto transaction (store.tx_begin_write ()); - store.initialize (transaction, genesis); + store.initialize (transaction, genesis, ledger.rep_weights); nano::keypair key; auto latest (ledger.latest (transaction, nano::test_genesis_key.pub)); nano::send_block send (latest, nano::test_genesis_key.pub, 0, nano::test_genesis_key.prv, nano::test_genesis_key.pub, system.work.generate (latest)); diff --git a/nano/rpc_test/rpc.cpp b/nano/rpc_test/rpc.cpp index 349425c8..3f79d92c 100644 --- a/nano/rpc_test/rpc.cpp +++ b/nano/rpc_test/rpc.cpp @@ -1970,8 +1970,7 @@ TEST (rpc, process_subtype_receive) TEST (rpc, keepalive) { nano::system system (24000, 1); - nano::node_init init1; - auto node1 (std::make_shared (init1, system.io_ctx, 24001, nano::unique_path (), system.alarm, system.logging, system.work)); + auto node1 (std::make_shared (system.io_ctx, 24001, nano::unique_path (), system.alarm, system.logging, system.work)); node1->start (); system.nodes.push_back (node1); auto node = system.nodes.front (); @@ -6108,7 +6107,6 @@ TEST (rpc, block_confirm_absent) TEST (rpc, block_confirm_confirmed) { nano::system system (24000, 1); - nano::node_init init; auto path (nano::unique_path ()); nano::node_config config; config.peering_port = 24001; @@ -6116,7 +6114,7 @@ TEST (rpc, block_confirm_confirmed) config.callback_port = 24002; config.callback_target = "/"; config.logging.init (path); - auto node (std::make_shared (init, system.io_ctx, path, system.alarm, config, system.work)); + auto node (std::make_shared (system.io_ctx, path, system.alarm, config, system.work)); node->start (); system.nodes.push_back (node); nano::genesis genesis; diff --git a/nano/secure/blockstore.hpp b/nano/secure/blockstore.hpp index 7c5a464e..f2c96f6c 100644 --- a/nano/secure/blockstore.hpp +++ b/nano/secure/blockstore.hpp @@ -565,6 +565,8 @@ private: std::unique_ptr impl; }; +class rep_weights; + /** * Manages block storage and iteration */ @@ -572,7 +574,7 @@ class block_store { public: virtual ~block_store () = default; - virtual void initialize (nano::write_transaction const &, nano::genesis const &) = 0; + virtual void initialize (nano::write_transaction const &, nano::genesis const &, nano::rep_weights &) = 0; virtual void block_put (nano::write_transaction const &, nano::block_hash const &, nano::block const &, nano::block_sideband const &, nano::epoch version = nano::epoch::epoch_0) = 0; virtual nano::block_hash block_successor (nano::transaction const &, nano::block_hash const &) const = 0; virtual void block_successor_clear (nano::write_transaction const &, nano::block_hash const &) = 0; @@ -627,12 +629,6 @@ public: virtual nano::uint128_t block_balance_calculated (std::shared_ptr, nano::block_sideband const &) const = 0; virtual nano::epoch block_version (nano::transaction const &, nano::block_hash const &) = 0; - virtual nano::uint128_t representation_get (nano::transaction const &, nano::account const &) = 0; - virtual void representation_put (nano::write_transaction const &, nano::account const &, nano::uint128_union const &) = 0; - virtual void representation_add (nano::write_transaction const &, nano::account const &, nano::uint128_t const &) = 0; - virtual nano::store_iterator representation_begin (nano::transaction const &) = 0; - virtual nano::store_iterator representation_end () = 0; - virtual void unchecked_clear (nano::write_transaction const &) = 0; virtual void unchecked_put (nano::write_transaction const &, nano::unchecked_key const &, nano::unchecked_info const &) = 0; virtual void unchecked_put (nano::write_transaction const &, nano::block_hash const &, std::shared_ptr const &) = 0; @@ -691,6 +687,8 @@ public: /** Not applicable to all sub-classes */ virtual void serialize_mdb_tracker (boost::property_tree::ptree &, std::chrono::milliseconds, std::chrono::milliseconds) = 0; + virtual bool init_error () const = 0; + /** Start read-write transaction */ virtual nano::write_transaction tx_begin_write (std::vector const & tables_to_lock = {}, std::vector const & tables_no_lock = {}) = 0; @@ -698,7 +696,7 @@ public: virtual nano::read_transaction tx_begin_read () = 0; }; -std::unique_ptr make_store (bool & init, nano::logger_mt & logger, boost::filesystem::path const & path, bool open_read_only = false, bool add_db_postfix = false, nano::txn_tracking_config const & txn_tracking_config_a = nano::txn_tracking_config{}, std::chrono::milliseconds block_processor_batch_max_time_a = std::chrono::milliseconds (5000), int lmdb_max_dbs = 128, bool drop_unchecked = false, size_t batch_size = 512, bool backup_before_upgrade = false); +std::unique_ptr make_store (nano::logger_mt & logger, boost::filesystem::path const & path, bool open_read_only = false, bool add_db_postfix = false, nano::txn_tracking_config const & txn_tracking_config_a = nano::txn_tracking_config{}, std::chrono::milliseconds block_processor_batch_max_time_a = std::chrono::milliseconds (5000), int lmdb_max_dbs = 128, bool drop_unchecked = false, size_t batch_size = 512, bool backup_before_upgrade = false); } namespace std diff --git a/nano/secure/blockstore_partial.hpp b/nano/secure/blockstore_partial.hpp index be900ad2..a3e4ff71 100644 --- a/nano/secure/blockstore_partial.hpp +++ b/nano/secure/blockstore_partial.hpp @@ -1,5 +1,6 @@ #pragma once +#include #include namespace nano @@ -23,7 +24,7 @@ public: * If using a different store version than the latest then you may need * to modify some of the objects in the store to be appropriate for the version before an upgrade. */ - void initialize (nano::write_transaction const & transaction_a, nano::genesis const & genesis_a) override + void initialize (nano::write_transaction const & transaction_a, nano::genesis const & genesis_a, nano::rep_weights & rep_weights) override { auto hash_l (genesis_a.hash ()); assert (latest_v0_begin (transaction_a) == latest_v0_end ()); @@ -32,7 +33,7 @@ public: block_put (transaction_a, hash_l, *genesis_a.open, sideband); confirmation_height_put (transaction_a, network_params.ledger.genesis_account, 1); account_put (transaction_a, network_params.ledger.genesis_account, { hash_l, genesis_a.open->hash (), genesis_a.open->hash (), std::numeric_limits::max (), nano::seconds_since_epoch (), 1, nano::epoch::epoch_0 }); - representation_put (transaction_a, network_params.ledger.genesis_account, std::numeric_limits::max ()); + rep_weights.representation_put (network_params.ledger.genesis_account, std::numeric_limits::max ()); frontier_put (transaction_a, hash_l, network_params.ledger.genesis_account); } @@ -44,15 +45,6 @@ public: return result; } - void representation_add (nano::write_transaction const & transaction_a, nano::block_hash const & source_a, nano::uint128_t const & amount_a) override - { - auto source_block (block_get (transaction_a, source_a)); - assert (source_block != nullptr); - auto source_rep (source_block->representative ()); - auto source_previous (representation_get (transaction_a, source_rep)); - representation_put (transaction_a, source_rep, source_previous + amount_a); - } - bool account_exists (nano::transaction const & transaction_a, nano::account const & account_a) override { auto iterator (latest_begin (transaction_a, account_a)); @@ -327,11 +319,6 @@ public: return result; } - nano::store_iterator representation_end () override - { - return nano::store_iterator (nullptr); - } - nano::store_iterator unchecked_end () override { return nano::store_iterator (nullptr); @@ -532,31 +519,6 @@ public: release_assert (success (status)); } - nano::uint128_t representation_get (nano::transaction const & transaction_a, nano::account const & account_a) override - { - nano::db_val value; - auto status (get (transaction_a, tables::representation, nano::db_val (account_a), value)); - release_assert (success (status) || not_found (status)); - nano::uint128_t result = 0; - if (success (status)) - { - nano::uint128_union rep; - nano::bufferstream stream (reinterpret_cast (value.data ()), value.size ()); - auto error (nano::try_read (stream, rep)); - (void)error; - assert (!error); - result = rep.number (); - } - return result; - } - - void representation_put (nano::write_transaction const & transaction_a, nano::account const & account_a, nano::uint128_union const & representation_a) override - { - nano::db_val rep (representation_a); - auto status (put (transaction_a, tables::representation, account_a, rep)); - release_assert (success (status)); - } - void unchecked_put (nano::write_transaction const & transaction_a, nano::unchecked_key const & key_a, nano::unchecked_info const & info_a) override { nano::db_val info (info_a); @@ -904,11 +866,6 @@ public: return make_merge_iterator (transaction_a, tables::pending_v0, tables::pending_v1); } - nano::store_iterator representation_begin (nano::transaction const & transaction_a) override - { - return make_iterator (transaction_a, tables::representation); - } - nano::store_iterator unchecked_begin (nano::transaction const & transaction_a) override { return make_iterator (transaction_a, tables::unchecked); diff --git a/nano/secure/ledger.cpp b/nano/secure/ledger.cpp index 07df8256..c6254e2a 100644 --- a/nano/secure/ledger.cpp +++ b/nano/secure/ledger.cpp @@ -1,3 +1,4 @@ +#include #include #include #include @@ -6,6 +7,14 @@ namespace { +void representation_add (nano::transaction const & transaction_a, nano::ledger & ledger_a, nano::block_hash const & source_a, nano::uint128_t const & amount_a) +{ + auto source_block (ledger_a.store.block_get (transaction_a, source_a)); + assert (source_block != nullptr); + auto source_rep (source_block->representative ()); + ledger_a.rep_weights.representation_add (source_rep, amount_a); +} + /** * Roll back the visited block */ @@ -35,7 +44,7 @@ public: (void)error; assert (!error); ledger.store.pending_del (transaction, key); - ledger.store.representation_add (transaction, ledger.representative (transaction, hash), pending.amount.number ()); + representation_add (transaction, ledger, ledger.representative (transaction, hash), pending.amount.number ()); ledger.change_latest (transaction, pending.source, block_a.hashables.previous, info.rep_block, ledger.balance (transaction, block_a.hashables.previous), info.block_count - 1); ledger.store.block_del (transaction, hash); ledger.store.frontier_del (transaction, hash); @@ -55,7 +64,7 @@ public: auto error (ledger.store.account_get (transaction, destination_account, info)); (void)error; assert (!error); - ledger.store.representation_add (transaction, ledger.representative (transaction, hash), 0 - amount); + representation_add (transaction, ledger, ledger.representative (transaction, hash), 0 - amount); ledger.change_latest (transaction, destination_account, block_a.hashables.previous, representative, ledger.balance (transaction, block_a.hashables.previous), info.block_count - 1); ledger.store.block_del (transaction, hash); ledger.store.pending_put (transaction, nano::pending_key (destination_account, block_a.hashables.source), { source_account, amount, nano::epoch::epoch_0 }); @@ -70,7 +79,7 @@ public: auto amount (ledger.amount (transaction, block_a.hashables.source)); auto destination_account (ledger.account (transaction, hash)); auto source_account (ledger.account (transaction, block_a.hashables.source)); - ledger.store.representation_add (transaction, ledger.representative (transaction, hash), 0 - amount); + representation_add (transaction, ledger, ledger.representative (transaction, hash), 0 - amount); ledger.change_latest (transaction, destination_account, 0, 0, 0, 0); ledger.store.block_del (transaction, hash); ledger.store.pending_put (transaction, nano::pending_key (destination_account, block_a.hashables.source), { source_account, amount, nano::epoch::epoch_0 }); @@ -87,8 +96,8 @@ public: (void)error; assert (!error); auto balance (ledger.balance (transaction, block_a.hashables.previous)); - ledger.store.representation_add (transaction, representative, balance); - ledger.store.representation_add (transaction, hash, 0 - balance); + representation_add (transaction, ledger, representative, balance); + representation_add (transaction, ledger, hash, 0 - balance); ledger.store.block_del (transaction, hash); ledger.change_latest (transaction, account, block_a.hashables.previous, representative, info.balance, info.block_count - 1); ledger.store.frontier_del (transaction, hash); @@ -107,11 +116,11 @@ public: auto balance (ledger.balance (transaction, block_a.hashables.previous)); auto is_send (block_a.hashables.balance < balance); // Add in amount delta - ledger.store.representation_add (transaction, hash, 0 - block_a.hashables.balance.number ()); + representation_add (transaction, ledger, hash, 0 - block_a.hashables.balance.number ()); if (!representative.is_zero ()) { // Move existing representation - ledger.store.representation_add (transaction, representative, balance); + representation_add (transaction, ledger, representative, balance); } nano::account_info info; @@ -318,10 +327,10 @@ void ledger_processor::state_block_impl (nano::state_block const & block_a) if (!info.rep_block.is_zero ()) { // Move existing representation - ledger.store.representation_add (transaction, info.rep_block, 0 - info.balance.number ()); + representation_add (transaction, ledger, info.rep_block, 0 - info.balance.number ()); } // Add in amount delta - ledger.store.representation_add (transaction, hash, block_a.hashables.balance.number ()); + representation_add (transaction, ledger, hash, block_a.hashables.balance.number ()); if (is_send) { @@ -448,8 +457,8 @@ void ledger_processor::change_block (nano::change_block const & block_a) nano::block_sideband sideband (nano::block_type::change, account, 0, info.balance, info.block_count + 1, nano::seconds_since_epoch ()); ledger.store.block_put (transaction, hash, block_a, sideband); auto balance (ledger.balance (transaction, block_a.hashables.previous)); - ledger.store.representation_add (transaction, hash, balance); - ledger.store.representation_add (transaction, info.rep_block, 0 - balance); + representation_add (transaction, ledger, hash, balance); + representation_add (transaction, ledger, info.rep_block, 0 - balance); ledger.change_latest (transaction, account, hash, hash, info.balance, info.block_count + 1); ledger.store.frontier_del (transaction, block_a.hashables.previous); ledger.store.frontier_put (transaction, hash, account); @@ -499,7 +508,7 @@ void ledger_processor::send_block (nano::send_block const & block_a) if (result.code == nano::process_result::progress) { auto amount (info.balance.number () - block_a.hashables.balance.number ()); - ledger.store.representation_add (transaction, info.rep_block, 0 - amount); + representation_add (transaction, ledger, info.rep_block, 0 - amount); nano::block_sideband sideband (nano::block_type::send, account, 0, block_a.hashables.balance /* unused */, info.block_count + 1, nano::seconds_since_epoch ()); ledger.store.block_put (transaction, hash, block_a, sideband); ledger.change_latest (transaction, account, hash, info.rep_block, block_a.hashables.balance, info.block_count + 1); @@ -570,7 +579,7 @@ void ledger_processor::receive_block (nano::receive_block const & block_a) nano::block_sideband sideband (nano::block_type::receive, account, 0, new_balance, info.block_count + 1, nano::seconds_since_epoch ()); ledger.store.block_put (transaction, hash, block_a, sideband); ledger.change_latest (transaction, account, hash, info.rep_block, new_balance, info.block_count + 1); - ledger.store.representation_add (transaction, info.rep_block, pending.amount.number ()); + representation_add (transaction, ledger, info.rep_block, pending.amount.number ()); ledger.store.frontier_del (transaction, block_a.hashables.previous); ledger.store.frontier_put (transaction, hash, account); result.account = account; @@ -633,7 +642,7 @@ void ledger_processor::open_block (nano::open_block const & block_a) nano::block_sideband sideband (nano::block_type::open, block_a.hashables.account, 0, pending.amount, 1, nano::seconds_since_epoch ()); ledger.store.block_put (transaction, hash, block_a, sideband); ledger.change_latest (transaction, block_a.hashables.account, hash, hash, pending.amount.number (), 1); - ledger.store.representation_add (transaction, hash, pending.amount.number ()); + representation_add (transaction, ledger, hash, pending.amount.number ()); ledger.store.frontier_put (transaction, hash, block_a.hashables.account); result.account = block_a.hashables.account; result.amount = pending.amount; @@ -668,13 +677,24 @@ bool nano::shared_ptr_block_hash::operator() (std::shared_ptr const return lhs->hash () == rhs->hash (); } -nano::ledger::ledger (nano::block_store & store_a, nano::stat & stat_a, nano::uint256_union const & epoch_link_a, nano::account const & epoch_signer_a) : +nano::ledger::ledger (nano::block_store & store_a, nano::stat & stat_a, nano::uint256_union const & epoch_link_a, nano::account const & epoch_signer_a, bool cache_reps_a) : store (store_a), stats (stat_a), check_bootstrap_weights (true), epoch_link (epoch_link_a), epoch_signer (epoch_signer_a) { + if (!store.init_error () && cache_reps_a) + { + auto transaction = store.tx_begin_read (); + for (auto i (store.latest_begin (transaction)), n (store.latest_end ()); i != n; ++i) + { + nano::account_info const & info (i->second); + auto block (store.block_get (transaction, info.rep_block)); + assert (block != nullptr); + rep_weights.representation_add (block->representative (), info.balance.number ()); + } + } } // Balance for account containing hash @@ -835,7 +855,7 @@ nano::uint128_t nano::ledger::weight (nano::transaction const & transaction_a, n check_bootstrap_weights = false; } } - return store.representation_get (transaction_a, account_a); + return rep_weights.representation_get (account_a); } // Rollback blocks until `block_a' doesn't exist or it tries to penetrate the confirmation height @@ -1101,9 +1121,10 @@ namespace nano std::unique_ptr collect_seq_con_info (ledger & ledger, const std::string & name) { auto composite = std::make_unique (name); - auto count = ledger.bootstrap_weights.size (); + auto count = ledger.bootstrap_weights_size.load (); auto sizeof_element = sizeof (decltype (ledger.bootstrap_weights)::value_type); composite->add_component (std::make_unique (seq_con_info{ "bootstrap_weights", count, sizeof_element })); + composite->add_component (collect_seq_con_info (ledger.rep_weights, "rep_weights")); return composite; } } diff --git a/nano/secure/ledger.hpp b/nano/secure/ledger.hpp index e21be446..a2f4cf53 100644 --- a/nano/secure/ledger.hpp +++ b/nano/secure/ledger.hpp @@ -1,6 +1,7 @@ #pragma once #include +#include #include namespace nano @@ -18,7 +19,7 @@ using tally_t = std::map, std::gre class ledger final { public: - ledger (nano::block_store &, nano::stat &, nano::uint256_union const & = 1, nano::account const & = 0); + ledger (nano::block_store &, nano::stat &, nano::uint256_union const & = 1, nano::account const & = 0, bool = true); nano::account account (nano::transaction const &, nano::block_hash const &) const; nano::uint128_t amount (nano::transaction const &, nano::block_hash const &); nano::uint128_t balance (nano::transaction const &, nano::block_hash const &) const; @@ -50,8 +51,10 @@ public: static nano::uint128_t const unit; nano::network_params network_params; nano::block_store & store; + nano::rep_weights rep_weights; nano::stat & stats; std::unordered_map bootstrap_weights; + std::atomic bootstrap_weights_size{ 0 }; uint64_t bootstrap_weight_max_blocks{ 1 }; std::atomic check_bootstrap_weights; nano::uint256_union epoch_link; diff --git a/nano/slow_test/node.cpp b/nano/slow_test/node.cpp index 15032d01..212757e3 100644 --- a/nano/slow_test/node.cpp +++ b/nano/slow_test/node.cpp @@ -56,9 +56,8 @@ TEST (system, receive_while_synchronizing) uint32_t count (1000); system.generate_mass_activity (count, *system.nodes[0]); nano::keypair key; - nano::node_init init1; - auto node1 (std::make_shared (init1, system.io_ctx, 24001, nano::unique_path (), system.alarm, system.logging, system.work)); - ASSERT_FALSE (init1.error ()); + auto node1 (std::make_shared (system.io_ctx, 24001, nano::unique_path (), system.alarm, system.logging, system.work)); + ASSERT_FALSE (node1->init_error ()); auto channel (std::make_shared (node1->network.udp_channels, system.nodes[0]->network.endpoint (), node1->network_params.protocol.protocol_version)); node1->network.send_keepalive (channel); auto wallet (node1->wallets.create (1)); @@ -90,14 +89,13 @@ TEST (system, receive_while_synchronizing) TEST (ledger, deep_account_compute) { nano::logger_mt logger; - bool init (false); - auto store = nano::make_store (init, logger, nano::unique_path ()); - ASSERT_FALSE (init); + auto store = nano::make_store (logger, nano::unique_path ()); + ASSERT_FALSE (store->init_error ()); nano::stat stats; nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis); + store->initialize (transaction, genesis, ledger.rep_weights); nano::work_pool pool (std::numeric_limits::max ()); nano::keypair key; auto balance (nano::genesis_amount - 1);