diff --git a/nano/core_test/block_store.cpp b/nano/core_test/block_store.cpp index 0cffb88adb..62ed1beb26 100644 --- a/nano/core_test/block_store.cpp +++ b/nano/core_test/block_store.cpp @@ -266,8 +266,9 @@ TEST (block_store, genesis) auto hash (genesis.hash ()); nano::rep_weights rep_weights; std::atomic cemented_count{ 0 }; + std::atomic block_count_cache{ 0 }; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, rep_weights, cemented_count); + store->initialize (transaction, genesis, rep_weights, cemented_count, block_count_cache); nano::account_info info; ASSERT_FALSE (store->account_get (transaction, nano::genesis_account, info)); ASSERT_EQ (hash, info.head); @@ -749,7 +750,8 @@ TEST (block_store, cemented_count_cache) nano::genesis genesis; nano::rep_weights rep_weights; std::atomic cemented_count{ 0 }; - store->initialize (transaction, genesis, rep_weights, cemented_count); + std::atomic block_count_cache{ 0 }; + store->initialize (transaction, genesis, rep_weights, cemented_count, block_count_cache); ASSERT_EQ (1, cemented_count); } @@ -797,19 +799,19 @@ TEST (mdb_block_store, upgrade_v2_v3) auto hash (genesis.hash ()); nano::stat stats; nano::ledger ledger (store, stats); - store.initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store.initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); 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 (); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, change).code); - ASSERT_EQ (0, ledger.weight (transaction, nano::test_genesis_key.pub)); - ASSERT_EQ (nano::genesis_amount, ledger.weight (transaction, key1.pub)); + ASSERT_EQ (0, ledger.weight (nano::test_genesis_key.pub)); + ASSERT_EQ (nano::genesis_amount, ledger.weight (key1.pub)); store.version_put (transaction, 2); ledger.rep_weights.representation_put (key1.pub, 7); - ASSERT_EQ (7, ledger.weight (transaction, key1.pub)); + ASSERT_EQ (7, ledger.weight (key1.pub)); ASSERT_EQ (2, store.version_get (transaction)); ledger.rep_weights.representation_put (key2.pub, 6); - ASSERT_EQ (6, ledger.weight (transaction, key2.pub)); + ASSERT_EQ (6, ledger.weight (key2.pub)); nano::account_info info; ASSERT_FALSE (store.account_get (transaction, nano::test_genesis_key.pub, info)); auto rep_block = ledger.representative (transaction, ledger.latest (transaction, nano::test_genesis_key.pub)); @@ -825,8 +827,8 @@ TEST (mdb_block_store, upgrade_v2_v3) auto transaction (store.tx_begin_write ()); 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)); + ASSERT_EQ (nano::genesis_amount, ledger.weight (key1.pub)); + ASSERT_EQ (0, ledger.weight (key2.pub)); nano::account_info info; ASSERT_FALSE (store.account_get (transaction, nano::test_genesis_key.pub, info)); ASSERT_EQ (change_hash, ledger.representative (transaction, ledger.latest (transaction, nano::test_genesis_key.pub))); @@ -877,7 +879,7 @@ TEST (mdb_block_store, upgrade_v4_v5) nano::genesis genesis; nano::stat stats; nano::ledger ledger (store, stats); - store.initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store.initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); store.version_put (transaction, 4); nano::account_info info; ASSERT_FALSE (store.account_get (transaction, nano::test_genesis_key.pub, info)); @@ -908,8 +910,9 @@ TEST (block_store, block_random) { nano::rep_weights rep_weights; std::atomic cemented_count{ 0 }; + std::atomic block_count_cache{ 0 }; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, rep_weights, cemented_count); + store->initialize (transaction, genesis, rep_weights, cemented_count, block_count_cache); } auto transaction (store->tx_begin_read ()); auto block (store->block_random (transaction)); @@ -928,7 +931,8 @@ TEST (mdb_block_store, upgrade_v5_v6) nano::genesis genesis; nano::rep_weights rep_weights; std::atomic cemented_count{ 0 }; - store.initialize (transaction, genesis, rep_weights, cemented_count); + std::atomic block_count_cache{ 0 }; + store.initialize (transaction, genesis, rep_weights, cemented_count, block_count_cache); store.version_put (transaction, 5); modify_genesis_account_info_to_v5 (store, transaction); } @@ -952,7 +956,8 @@ TEST (mdb_block_store, upgrade_v6_v7) nano::genesis genesis; nano::rep_weights rep_weights; std::atomic cemented_count{ 0 }; - store.initialize (transaction, genesis, rep_weights, cemented_count); + std::atomic block_count_cache{ 0 }; + store.initialize (transaction, genesis, rep_weights, cemented_count, block_count_cache); 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)); @@ -1115,7 +1120,8 @@ TEST (block_store, state_block) auto transaction (store->tx_begin_write ()); nano::rep_weights rep_weights; std::atomic cemented_count{ 0 }; - store->initialize (transaction, genesis, rep_weights, cemented_count); + std::atomic block_count_cache{ 0 }; + store->initialize (transaction, genesis, rep_weights, cemented_count, block_count_cache); 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); @@ -1171,7 +1177,8 @@ TEST (mdb_block_store, upgrade_sideband_genesis) store.version_put (transaction, 11); nano::rep_weights rep_weights; std::atomic cemented_count{ 0 }; - store.initialize (transaction, genesis, rep_weights, cemented_count); + std::atomic block_count_cache{ 0 }; + store.initialize (transaction, genesis, rep_weights, cemented_count, block_count_cache); modify_account_info_to_v13 (store, transaction, nano::genesis_account); nano::block_sideband sideband; auto genesis_block (store.block_get (transaction, genesis.hash (), &sideband)); @@ -1206,7 +1213,7 @@ TEST (mdb_block_store, upgrade_sideband_two_blocks) nano::ledger ledger (store, stat); auto transaction (store.tx_begin_write ()); store.version_put (transaction, 11); - store.initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store.initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); 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 (); @@ -1244,7 +1251,7 @@ TEST (mdb_block_store, upgrade_sideband_two_accounts) nano::ledger ledger (store, stat); auto transaction (store.tx_begin_write ()); store.version_put (transaction, 11); - store.initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store.initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); 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 (); @@ -1287,7 +1294,7 @@ TEST (mdb_block_store, insert_after_legacy) nano::ledger ledger (store, stat); auto transaction (store.tx_begin_write ()); store.version_put (transaction, 11); - store.initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store.initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); 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 ())); @@ -1304,7 +1311,7 @@ TEST (mdb_block_store, legacy_account_computed) nano::ledger ledger (store, stats); nano::genesis genesis; auto transaction (store.tx_begin_write ()); - store.initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store.initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); 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 ())); @@ -1325,7 +1332,7 @@ TEST (mdb_block_store, upgrade_sideband_epoch) nano::ledger ledger (store, stat); auto transaction (store.tx_begin_write ()); store.version_put (transaction, 11); - store.initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store.initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); nano::state_block block1 (nano::test_genesis_key.pub, genesis.hash (), nano::test_genesis_key.pub, nano::genesis_amount, ledger.link (nano::epoch::epoch_1), 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); @@ -1362,7 +1369,7 @@ TEST (mdb_block_store, sideband_height) nano::stat stat; nano::ledger ledger (store, stat); auto transaction (store.tx_begin_write ()); - store.initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store.initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); 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); @@ -1560,7 +1567,8 @@ TEST (mdb_block_store, upgrade_v13_v14) auto transaction (store.tx_begin_write ()); nano::rep_weights rep_weights; std::atomic cemented_count{ 0 }; - store.initialize (transaction, genesis, rep_weights, cemented_count); + std::atomic block_count_cache{ 0 }; + store.initialize (transaction, genesis, rep_weights, cemented_count, block_count_cache); nano::account_info account_info; ASSERT_FALSE (store.account_get (transaction, nano::genesis_account, account_info)); uint64_t confirmation_height; @@ -1613,7 +1621,8 @@ TEST (mdb_block_store, upgrade_v14_v15) auto transaction (store.tx_begin_write ()); nano::rep_weights rep_weights; std::atomic cemented_count{ 0 }; - store.initialize (transaction, genesis, rep_weights, cemented_count); + std::atomic block_count_cache{ 0 }; + store.initialize (transaction, genesis, rep_weights, cemented_count, block_count_cache); nano::account_info account_info; ASSERT_FALSE (store.account_get (transaction, nano::genesis_account, account_info)); uint64_t confirmation_height; @@ -1754,7 +1763,8 @@ TEST (block_store, upgrade_confirmation_height_many) store.version_put (transaction, 13); nano::rep_weights rep_weights; std::atomic cemented_count{ 0 }; - store.initialize (transaction, genesis, rep_weights, cemented_count); + std::atomic block_count_cache{ 0 }; + store.initialize (transaction, genesis, rep_weights, cemented_count, block_count_cache); modify_account_info_to_v13 (store, transaction, nano::genesis_account); // Add many accounts diff --git a/nano/core_test/ledger.cpp b/nano/core_test/ledger.cpp index 3fdc98b235..e118ece2f3 100644 --- a/nano/core_test/ledger.cpp +++ b/nano/core_test/ledger.cpp @@ -44,7 +44,7 @@ TEST (ledger, genesis_balance) nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); auto balance (ledger.account_balance (transaction, nano::genesis_account)); ASSERT_EQ (nano::genesis_amount, balance); auto amount (ledger.amount (transaction, nano::genesis_account)); @@ -81,7 +81,7 @@ TEST (ledger, process_send) nano::ledger ledger (*store, stats); auto transaction (store->tx_begin_write ()); nano::genesis genesis; - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); nano::work_pool pool (std::numeric_limits::max ()); nano::account_info info1; ASSERT_FALSE (store->account_get (transaction, nano::test_genesis_key.pub, info1)); @@ -120,8 +120,8 @@ TEST (ledger, process_send) ASSERT_EQ (key2.pub, store->frontier_get (transaction, hash2)); ASSERT_EQ (nano::genesis_amount - 50, ledger.account_balance (transaction, key2.pub)); ASSERT_EQ (0, ledger.account_pending (transaction, key2.pub)); - ASSERT_EQ (50, ledger.weight (transaction, nano::test_genesis_key.pub)); - ASSERT_EQ (nano::genesis_amount - 50, ledger.weight (transaction, key2.pub)); + ASSERT_EQ (50, ledger.weight (nano::test_genesis_key.pub)); + ASSERT_EQ (nano::genesis_amount - 50, ledger.weight (key2.pub)); nano::account_info info3; ASSERT_FALSE (store->account_get (transaction, nano::test_genesis_key.pub, info3)); auto latest2 (store->block_get (transaction, info3.head)); @@ -147,13 +147,13 @@ TEST (ledger, process_send) ASSERT_EQ (0, ledger.account_balance (transaction, key2.pub)); ASSERT_EQ (nano::genesis_amount - 50, ledger.account_pending (transaction, key2.pub)); ASSERT_EQ (50, ledger.account_balance (transaction, nano::test_genesis_key.pub)); - ASSERT_EQ (50, ledger.weight (transaction, nano::test_genesis_key.pub)); - ASSERT_EQ (0, ledger.weight (transaction, key2.pub)); + ASSERT_EQ (50, ledger.weight (nano::test_genesis_key.pub)); + ASSERT_EQ (0, ledger.weight (key2.pub)); nano::account_info info6; ASSERT_FALSE (ledger.store.account_get (transaction, nano::test_genesis_key.pub, info6)); ASSERT_EQ (hash1, info6.head); ASSERT_FALSE (ledger.rollback (transaction, info6.head)); - ASSERT_EQ (nano::genesis_amount, ledger.weight (transaction, nano::test_genesis_key.pub)); + ASSERT_EQ (nano::genesis_amount, ledger.weight (nano::test_genesis_key.pub)); ASSERT_EQ (nano::test_genesis_key.pub, store->frontier_get (transaction, info1.head)); ASSERT_TRUE (store->frontier_get (transaction, hash1).is_zero ()); nano::account_info info7; @@ -175,7 +175,7 @@ TEST (ledger, process_receive) nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); nano::work_pool pool (std::numeric_limits::max ()); nano::account_info info1; ASSERT_FALSE (store->account_get (transaction, nano::test_genesis_key.pub, info1)); @@ -190,7 +190,7 @@ TEST (ledger, process_receive) ASSERT_EQ (nano::process_result::progress, return1.code); ASSERT_EQ (key2.pub, return1.account); ASSERT_EQ (nano::genesis_amount - 50, return1.amount.number ()); - ASSERT_EQ (nano::genesis_amount - 50, ledger.weight (transaction, key3.pub)); + ASSERT_EQ (nano::genesis_amount - 50, ledger.weight (key3.pub)); nano::send_block send2 (hash1, key2.pub, 25, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (hash1)); nano::block_hash hash3 (send2.hash ()); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send2).code); @@ -208,7 +208,7 @@ TEST (ledger, process_receive) ASSERT_EQ (25, ledger.account_balance (transaction, nano::test_genesis_key.pub)); ASSERT_EQ (0, ledger.account_pending (transaction, key2.pub)); ASSERT_EQ (nano::genesis_amount - 25, ledger.account_balance (transaction, key2.pub)); - ASSERT_EQ (nano::genesis_amount - 25, ledger.weight (transaction, key3.pub)); + ASSERT_EQ (nano::genesis_amount - 25, ledger.weight (key3.pub)); ASSERT_FALSE (ledger.rollback (transaction, hash4)); ASSERT_TRUE (store->block_successor (transaction, hash2).is_zero ()); ASSERT_EQ (key2.pub, store->frontier_get (transaction, hash2)); @@ -216,7 +216,7 @@ TEST (ledger, process_receive) ASSERT_EQ (25, ledger.account_balance (transaction, nano::test_genesis_key.pub)); ASSERT_EQ (25, ledger.account_pending (transaction, key2.pub)); ASSERT_EQ (nano::genesis_amount - 50, ledger.account_balance (transaction, key2.pub)); - ASSERT_EQ (nano::genesis_amount - 50, ledger.weight (transaction, key3.pub)); + ASSERT_EQ (nano::genesis_amount - 50, ledger.weight (key3.pub)); ASSERT_EQ (hash2, ledger.latest (transaction, key2.pub)); nano::pending_info pending1; ASSERT_FALSE (ledger.store.pending_get (transaction, nano::pending_key (key2.pub, hash3), pending1)); @@ -233,7 +233,7 @@ TEST (ledger, rollback_receiver) nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); nano::work_pool pool (std::numeric_limits::max ()); nano::account_info info1; ASSERT_FALSE (store->account_get (transaction, nano::test_genesis_key.pub, info1)); @@ -248,15 +248,15 @@ TEST (ledger, rollback_receiver) ASSERT_EQ (hash2, ledger.latest (transaction, key2.pub)); ASSERT_EQ (50, ledger.account_balance (transaction, nano::test_genesis_key.pub)); ASSERT_EQ (nano::genesis_amount - 50, ledger.account_balance (transaction, key2.pub)); - ASSERT_EQ (50, ledger.weight (transaction, nano::test_genesis_key.pub)); - ASSERT_EQ (0, ledger.weight (transaction, key2.pub)); - ASSERT_EQ (nano::genesis_amount - 50, ledger.weight (transaction, key3.pub)); + ASSERT_EQ (50, ledger.weight (nano::test_genesis_key.pub)); + ASSERT_EQ (0, ledger.weight (key2.pub)); + ASSERT_EQ (nano::genesis_amount - 50, ledger.weight (key3.pub)); ASSERT_FALSE (ledger.rollback (transaction, hash1)); ASSERT_EQ (nano::genesis_amount, ledger.account_balance (transaction, nano::test_genesis_key.pub)); ASSERT_EQ (0, ledger.account_balance (transaction, key2.pub)); - ASSERT_EQ (nano::genesis_amount, ledger.weight (transaction, nano::test_genesis_key.pub)); - ASSERT_EQ (0, ledger.weight (transaction, key2.pub)); - ASSERT_EQ (0, ledger.weight (transaction, key3.pub)); + ASSERT_EQ (nano::genesis_amount, ledger.weight (nano::test_genesis_key.pub)); + ASSERT_EQ (0, ledger.weight (key2.pub)); + ASSERT_EQ (0, ledger.weight (key3.pub)); nano::account_info info2; ASSERT_TRUE (ledger.store.account_get (transaction, key2.pub, info2)); nano::pending_info pending1; @@ -272,7 +272,7 @@ TEST (ledger, rollback_representation) nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); 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 ())); @@ -290,8 +290,8 @@ TEST (ledger, rollback_representation) ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send2).code); nano::receive_block receive1 (open.hash (), send2.hash (), key2.prv, key2.pub, pool.generate (open.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, receive1).code); - ASSERT_EQ (1, ledger.weight (transaction, key3.pub)); - ASSERT_EQ (nano::genesis_amount - 1, ledger.weight (transaction, key4.pub)); + ASSERT_EQ (1, ledger.weight (key3.pub)); + ASSERT_EQ (nano::genesis_amount - 1, ledger.weight (key4.pub)); nano::account_info info1; ASSERT_FALSE (store->account_get (transaction, key2.pub, info1)); ASSERT_EQ (key4.pub, info1.representative); @@ -299,13 +299,13 @@ TEST (ledger, rollback_representation) nano::account_info info2; ASSERT_FALSE (store->account_get (transaction, key2.pub, info2)); ASSERT_EQ (key4.pub, info2.representative); - ASSERT_EQ (0, ledger.weight (transaction, key2.pub)); - ASSERT_EQ (nano::genesis_amount - 50, ledger.weight (transaction, key4.pub)); + ASSERT_EQ (0, ledger.weight (key2.pub)); + ASSERT_EQ (nano::genesis_amount - 50, ledger.weight (key4.pub)); ASSERT_FALSE (ledger.rollback (transaction, open.hash ())); - ASSERT_EQ (1, ledger.weight (transaction, key3.pub)); - ASSERT_EQ (0, ledger.weight (transaction, key4.pub)); + ASSERT_EQ (1, ledger.weight (key3.pub)); + ASSERT_EQ (0, ledger.weight (key4.pub)); ledger.rollback (transaction, send1.hash ()); - ASSERT_EQ (nano::genesis_amount, ledger.weight (transaction, key3.pub)); + ASSERT_EQ (nano::genesis_amount, ledger.weight (key3.pub)); nano::account_info info3; ASSERT_FALSE (store->account_get (transaction, nano::test_genesis_key.pub, info3)); ASSERT_EQ (key3.pub, info3.representative); @@ -313,8 +313,8 @@ TEST (ledger, rollback_representation) nano::account_info info4; ASSERT_FALSE (store->account_get (transaction, nano::test_genesis_key.pub, info4)); ASSERT_EQ (key5.pub, info4.representative); - ASSERT_EQ (nano::genesis_amount, ledger.weight (transaction, key5.pub)); - ASSERT_EQ (0, ledger.weight (transaction, key3.pub)); + ASSERT_EQ (nano::genesis_amount, ledger.weight (key5.pub)); + ASSERT_EQ (0, ledger.weight (key3.pub)); } TEST (ledger, receive_rollback) @@ -326,7 +326,7 @@ TEST (ledger, receive_rollback) nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); 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); @@ -344,7 +344,7 @@ TEST (ledger, process_duplicate) nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); nano::work_pool pool (std::numeric_limits::max ()); nano::account_info info1; ASSERT_FALSE (store->account_get (transaction, nano::test_genesis_key.pub, info1)); @@ -367,7 +367,7 @@ TEST (ledger, representative_genesis) nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); auto latest (ledger.latest (transaction, nano::test_genesis_key.pub)); ASSERT_FALSE (latest.is_zero ()); ASSERT_EQ (genesis.open->hash (), ledger.representative (transaction, latest)); @@ -382,8 +382,8 @@ TEST (ledger, weight) nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); - ASSERT_EQ (nano::genesis_amount, ledger.weight (transaction, nano::genesis_account)); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); + ASSERT_EQ (nano::genesis_amount, ledger.weight (nano::genesis_account)); } TEST (ledger, representative_change) @@ -396,10 +396,10 @@ TEST (ledger, representative_change) nano::keypair key2; nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); 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)); + ASSERT_EQ (nano::genesis_amount, ledger.weight (nano::test_genesis_key.pub)); + ASSERT_EQ (0, ledger.weight (key2.pub)); nano::account_info info1; ASSERT_FALSE (store->account_get (transaction, nano::test_genesis_key.pub, info1)); nano::change_block block (info1.head, key2.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (info1.head)); @@ -410,8 +410,8 @@ TEST (ledger, representative_change) ASSERT_EQ (nano::test_genesis_key.pub, store->frontier_get (transaction, block.hash ())); ASSERT_EQ (nano::process_result::progress, return1.code); ASSERT_EQ (nano::test_genesis_key.pub, return1.account); - ASSERT_EQ (0, ledger.weight (transaction, nano::test_genesis_key.pub)); - ASSERT_EQ (nano::genesis_amount, ledger.weight (transaction, key2.pub)); + ASSERT_EQ (0, ledger.weight (nano::test_genesis_key.pub)); + ASSERT_EQ (nano::genesis_amount, ledger.weight (key2.pub)); nano::account_info info2; ASSERT_FALSE (store->account_get (transaction, nano::test_genesis_key.pub, info2)); ASSERT_EQ (block.hash (), info2.head); @@ -421,8 +421,8 @@ TEST (ledger, representative_change) nano::account_info info3; ASSERT_FALSE (store->account_get (transaction, nano::test_genesis_key.pub, info3)); ASSERT_EQ (info1.head, info3.head); - ASSERT_EQ (nano::genesis_amount, ledger.weight (transaction, nano::test_genesis_key.pub)); - ASSERT_EQ (0, ledger.weight (transaction, key2.pub)); + ASSERT_EQ (nano::genesis_amount, ledger.weight (nano::test_genesis_key.pub)); + ASSERT_EQ (0, ledger.weight (key2.pub)); } TEST (ledger, send_fork) @@ -436,7 +436,7 @@ TEST (ledger, send_fork) nano::keypair key3; nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); nano::work_pool pool (std::numeric_limits::max ()); nano::account_info info1; ASSERT_FALSE (store->account_get (transaction, nano::test_genesis_key.pub, info1)); @@ -457,7 +457,7 @@ TEST (ledger, receive_fork) nano::keypair key3; nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); nano::work_pool pool (std::numeric_limits::max ()); nano::account_info info1; ASSERT_FALSE (store->account_get (transaction, nano::test_genesis_key.pub, info1)); @@ -484,7 +484,7 @@ TEST (ledger, open_fork) nano::keypair key3; nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); nano::work_pool pool (std::numeric_limits::max ()); nano::account_info info1; ASSERT_FALSE (store->account_get (transaction, nano::test_genesis_key.pub, info1)); @@ -614,7 +614,7 @@ TEST (ledger, representation) auto & rep_weights = ledger.rep_weights; nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, rep_weights, ledger.cemented_count, ledger.block_count_cache); nano::work_pool pool (std::numeric_limits::max ()); ASSERT_EQ (nano::genesis_amount, rep_weights.representation_get (nano::test_genesis_key.pub)); nano::keypair key2; @@ -688,7 +688,7 @@ TEST (ledger, double_open) nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); 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 ())); @@ -708,7 +708,7 @@ TEST (ledger, double_receive) nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); 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 ())); @@ -770,7 +770,7 @@ TEST (votes, add_one) auto existing1 (votes1->last_votes.find (nano::test_genesis_key.pub)); ASSERT_NE (votes1->last_votes.end (), existing1); ASSERT_EQ (send1->hash (), existing1->second.hash); - auto winner (*votes1->tally (transaction).begin ()); + auto winner (*votes1->tally ().begin ()); ASSERT_EQ (*send1, *winner.second); ASSERT_EQ (nano::genesis_amount - 100, winner.first); } @@ -801,7 +801,7 @@ TEST (votes, add_two) ASSERT_EQ (send1->hash (), votes1->last_votes[nano::test_genesis_key.pub].hash); ASSERT_NE (votes1->last_votes.end (), votes1->last_votes.find (key2.pub)); ASSERT_EQ (send2->hash (), votes1->last_votes[key2.pub].hash); - auto winner (*votes1->tally (transaction).begin ()); + auto winner (*votes1->tally ().begin ()); ASSERT_EQ (*send1, *winner.second); } @@ -851,7 +851,7 @@ TEST (votes, add_existing) ASSERT_EQ (send2->hash (), votes1->last_votes[nano::test_genesis_key.pub].hash); { auto transaction (node1.store.tx_begin_read ()); - auto winner (*votes1->tally (transaction).begin ()); + auto winner (*votes1->tally ().begin ()); ASSERT_EQ (*send2, *winner.second); } } @@ -882,7 +882,7 @@ TEST (votes, add_old) ASSERT_EQ (2, votes1->last_votes.size ()); ASSERT_NE (votes1->last_votes.end (), votes1->last_votes.find (nano::test_genesis_key.pub)); ASSERT_EQ (send1->hash (), votes1->last_votes[nano::test_genesis_key.pub].hash); - auto winner (*votes1->tally (transaction).begin ()); + auto winner (*votes1->tally ().begin ()); ASSERT_EQ (*send1, *winner.second); } @@ -922,9 +922,9 @@ TEST (votes, add_old_different_account) ASSERT_NE (votes2->last_votes.end (), votes2->last_votes.find (nano::test_genesis_key.pub)); ASSERT_EQ (send1->hash (), votes1->last_votes[nano::test_genesis_key.pub].hash); ASSERT_EQ (send2->hash (), votes2->last_votes[nano::test_genesis_key.pub].hash); - auto winner1 (*votes1->tally (transaction).begin ()); + auto winner1 (*votes1->tally ().begin ()); ASSERT_EQ (*send1, *winner1.second); - auto winner2 (*votes2->tally (transaction).begin ()); + auto winner2 (*votes2->tally ().begin ()); ASSERT_EQ (*send2, *winner2.second); } @@ -953,7 +953,7 @@ TEST (votes, add_cooldown) ASSERT_EQ (2, votes1->last_votes.size ()); ASSERT_NE (votes1->last_votes.end (), votes1->last_votes.find (nano::test_genesis_key.pub)); ASSERT_EQ (send1->hash (), votes1->last_votes[nano::test_genesis_key.pub].hash); - auto winner (*votes1->tally (transaction).begin ()); + auto winner (*votes1->tally ().begin ()); ASSERT_EQ (*send1, *winner.second); } @@ -981,7 +981,7 @@ TEST (ledger, fail_change_old) nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); 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 ())); @@ -1000,7 +1000,7 @@ TEST (ledger, fail_change_gap_previous) nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); 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)); @@ -1017,7 +1017,7 @@ TEST (ledger, fail_change_bad_signature) nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); 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 ())); @@ -1034,7 +1034,7 @@ TEST (ledger, fail_change_fork) nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); 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 ())); @@ -1055,7 +1055,7 @@ TEST (ledger, fail_send_old) nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); 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 ())); @@ -1074,7 +1074,7 @@ TEST (ledger, fail_send_gap_previous) nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); 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)); @@ -1091,7 +1091,7 @@ TEST (ledger, fail_send_bad_signature) nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); 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 ())); @@ -1108,7 +1108,7 @@ TEST (ledger, fail_send_negative_spend) nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); 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 ())); @@ -1127,7 +1127,7 @@ TEST (ledger, fail_send_fork) nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); 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 ())); @@ -1146,7 +1146,7 @@ TEST (ledger, fail_open_old) nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); 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 ())); @@ -1165,7 +1165,7 @@ TEST (ledger, fail_open_gap_source) nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); 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)); @@ -1182,7 +1182,7 @@ TEST (ledger, fail_open_bad_signature) nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); 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 ())); @@ -1201,7 +1201,7 @@ TEST (ledger, fail_open_fork_previous) nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); 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 ())); @@ -1223,7 +1223,7 @@ TEST (ledger, fail_open_account_mismatch) nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); 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 ())); @@ -1242,7 +1242,7 @@ TEST (ledger, fail_receive_old) nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); 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 ())); @@ -1265,7 +1265,7 @@ TEST (ledger, fail_receive_gap_source) nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); 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 ())); @@ -1291,7 +1291,7 @@ TEST (ledger, fail_receive_overreceive) nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); 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 ())); @@ -1314,7 +1314,7 @@ TEST (ledger, fail_receive_bad_signature) nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); 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 ())); @@ -1340,7 +1340,7 @@ TEST (ledger, fail_receive_gap_previous_opened) nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); 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 ())); @@ -1366,7 +1366,7 @@ TEST (ledger, fail_receive_gap_previous_unopened) nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); 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 ())); @@ -1389,7 +1389,7 @@ TEST (ledger, fail_receive_fork_previous) nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); 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 ())); @@ -1419,7 +1419,7 @@ TEST (ledger, fail_receive_received_source) nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); 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 ())); @@ -1468,7 +1468,7 @@ TEST (ledger, latest_root) nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); nano::work_pool pool (std::numeric_limits::max ()); nano::keypair key; ASSERT_EQ (key.pub, ledger.latest_root (transaction, key.pub)); @@ -1488,20 +1488,20 @@ TEST (ledger, change_representative_move_representation) nano::keypair key1; auto transaction (store->tx_begin_write ()); nano::genesis genesis; - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); 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)); + ASSERT_EQ (nano::genesis_amount, ledger.weight (nano::test_genesis_key.pub)); nano::send_block send (hash1, key1.pub, 0, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (hash1)); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send).code); - ASSERT_EQ (0, ledger.weight (transaction, nano::test_genesis_key.pub)); + ASSERT_EQ (0, ledger.weight (nano::test_genesis_key.pub)); nano::keypair key2; nano::change_block change (send.hash (), key2.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (send.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, change).code); nano::keypair key3; nano::open_block open (send.hash (), key3.pub, key1.pub, key1.prv, key1.pub, pool.generate (key1.pub)); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, open).code); - ASSERT_EQ (nano::genesis_amount, ledger.weight (transaction, key3.pub)); + ASSERT_EQ (nano::genesis_amount, ledger.weight (key3.pub)); } TEST (ledger, send_open_receive_rollback) @@ -1513,7 +1513,7 @@ TEST (ledger, send_open_receive_rollback) nano::ledger ledger (*store, stats); auto transaction (store->tx_begin_write ()); nano::genesis genesis; - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); nano::work_pool pool (std::numeric_limits::max ()); nano::account_info info1; ASSERT_FALSE (store->account_get (transaction, nano::test_genesis_key.pub, info1)); @@ -1532,35 +1532,35 @@ TEST (ledger, send_open_receive_rollback) auto return5 (ledger.process (transaction, receive)); ASSERT_EQ (nano::process_result::progress, return5.code); nano::keypair key3; - ASSERT_EQ (100, ledger.weight (transaction, key2.pub)); - ASSERT_EQ (nano::genesis_amount - 100, ledger.weight (transaction, nano::test_genesis_key.pub)); - ASSERT_EQ (0, ledger.weight (transaction, key3.pub)); + ASSERT_EQ (100, ledger.weight (key2.pub)); + ASSERT_EQ (nano::genesis_amount - 100, ledger.weight (nano::test_genesis_key.pub)); + ASSERT_EQ (0, ledger.weight (key3.pub)); nano::change_block change1 (send2.hash (), key3.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (send2.hash ())); auto return6 (ledger.process (transaction, change1)); ASSERT_EQ (nano::process_result::progress, return6.code); - ASSERT_EQ (100, ledger.weight (transaction, key2.pub)); - ASSERT_EQ (0, ledger.weight (transaction, nano::test_genesis_key.pub)); - ASSERT_EQ (nano::genesis_amount - 100, ledger.weight (transaction, key3.pub)); + ASSERT_EQ (100, ledger.weight (key2.pub)); + ASSERT_EQ (0, ledger.weight (nano::test_genesis_key.pub)); + ASSERT_EQ (nano::genesis_amount - 100, ledger.weight (key3.pub)); ASSERT_FALSE (ledger.rollback (transaction, receive.hash ())); - ASSERT_EQ (50, ledger.weight (transaction, key2.pub)); - ASSERT_EQ (0, ledger.weight (transaction, nano::test_genesis_key.pub)); - ASSERT_EQ (nano::genesis_amount - 100, ledger.weight (transaction, key3.pub)); + ASSERT_EQ (50, ledger.weight (key2.pub)); + ASSERT_EQ (0, ledger.weight (nano::test_genesis_key.pub)); + ASSERT_EQ (nano::genesis_amount - 100, ledger.weight (key3.pub)); ASSERT_FALSE (ledger.rollback (transaction, open.hash ())); - ASSERT_EQ (0, ledger.weight (transaction, key2.pub)); - ASSERT_EQ (0, ledger.weight (transaction, nano::test_genesis_key.pub)); - ASSERT_EQ (nano::genesis_amount - 100, ledger.weight (transaction, key3.pub)); + ASSERT_EQ (0, ledger.weight (key2.pub)); + ASSERT_EQ (0, ledger.weight (nano::test_genesis_key.pub)); + ASSERT_EQ (nano::genesis_amount - 100, ledger.weight (key3.pub)); ASSERT_FALSE (ledger.rollback (transaction, change1.hash ())); - ASSERT_EQ (0, ledger.weight (transaction, key2.pub)); - ASSERT_EQ (0, ledger.weight (transaction, key3.pub)); - ASSERT_EQ (nano::genesis_amount - 100, ledger.weight (transaction, nano::test_genesis_key.pub)); + ASSERT_EQ (0, ledger.weight (key2.pub)); + ASSERT_EQ (0, ledger.weight (key3.pub)); + ASSERT_EQ (nano::genesis_amount - 100, ledger.weight (nano::test_genesis_key.pub)); ASSERT_FALSE (ledger.rollback (transaction, send2.hash ())); - ASSERT_EQ (0, ledger.weight (transaction, key2.pub)); - ASSERT_EQ (0, ledger.weight (transaction, key3.pub)); - ASSERT_EQ (nano::genesis_amount - 50, ledger.weight (transaction, nano::test_genesis_key.pub)); + ASSERT_EQ (0, ledger.weight (key2.pub)); + ASSERT_EQ (0, ledger.weight (key3.pub)); + ASSERT_EQ (nano::genesis_amount - 50, ledger.weight (nano::test_genesis_key.pub)); ASSERT_FALSE (ledger.rollback (transaction, send1.hash ())); - ASSERT_EQ (0, ledger.weight (transaction, key2.pub)); - ASSERT_EQ (0, ledger.weight (transaction, key3.pub)); - ASSERT_EQ (nano::genesis_amount - 0, ledger.weight (transaction, nano::test_genesis_key.pub)); + ASSERT_EQ (0, ledger.weight (key2.pub)); + ASSERT_EQ (0, ledger.weight (key3.pub)); + ASSERT_EQ (nano::genesis_amount - 0, ledger.weight (nano::test_genesis_key.pub)); } TEST (ledger, bootstrap_rep_weight) @@ -1576,26 +1576,27 @@ TEST (ledger, bootstrap_rep_weight) nano::work_pool pool (std::numeric_limits::max ()); { auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); 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); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send).code); } + ASSERT_EQ (2, ledger.block_count_cache); { - auto transaction (store->tx_begin_read ()); ledger.bootstrap_weight_max_blocks = 3; ledger.bootstrap_weights[key2.pub] = 1000; - ASSERT_EQ (1000, ledger.weight (transaction, key2.pub)); + ASSERT_EQ (1000, ledger.weight (key2.pub)); } { auto transaction (store->tx_begin_write ()); ASSERT_FALSE (store->account_get (transaction, nano::test_genesis_key.pub, info1)); nano::send_block send (info1.head, key2.pub, std::numeric_limits::max () - 100, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (info1.head)); - ledger.process (transaction, send); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send).code); } + ASSERT_EQ (3, ledger.block_count_cache); { auto transaction (store->tx_begin_read ()); - ASSERT_EQ (0, ledger.weight (transaction, key2.pub)); + ASSERT_EQ (0, ledger.weight (key2.pub)); } } @@ -1608,7 +1609,7 @@ TEST (ledger, block_destination_source) nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); nano::work_pool pool (std::numeric_limits::max ()); nano::keypair dest; nano::uint128_t balance (nano::genesis_amount); @@ -1654,7 +1655,7 @@ TEST (ledger, state_account) nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); nano::work_pool pool (std::numeric_limits::max ()); nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::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); @@ -1670,7 +1671,7 @@ TEST (ledger, state_send_receive) nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); nano::work_pool pool (std::numeric_limits::max ()); nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::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); @@ -1680,7 +1681,7 @@ TEST (ledger, state_send_receive) ASSERT_EQ (send1, *send2); ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.balance (transaction, send1.hash ())); ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, send1.hash ())); - ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.weight (transaction, nano::genesis_account)); + ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::genesis_account)); ASSERT_TRUE (store->pending_exists (transaction, nano::pending_key (nano::genesis_account, send1.hash ()))); nano::state_block receive1 (nano::genesis_account, send1.hash (), nano::genesis_account, nano::genesis_amount, send1.hash (), nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (send1.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, receive1).code); @@ -1690,7 +1691,7 @@ TEST (ledger, state_send_receive) ASSERT_EQ (receive1, *receive2); ASSERT_EQ (nano::genesis_amount, ledger.balance (transaction, receive1.hash ())); ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, receive1.hash ())); - ASSERT_EQ (nano::genesis_amount, ledger.weight (transaction, nano::genesis_account)); + ASSERT_EQ (nano::genesis_amount, ledger.weight (nano::genesis_account)); ASSERT_FALSE (store->pending_exists (transaction, nano::pending_key (nano::genesis_account, send1.hash ()))); } @@ -1703,7 +1704,7 @@ TEST (ledger, state_receive) nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); 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); @@ -1713,7 +1714,7 @@ TEST (ledger, state_receive) ASSERT_EQ (send1, *send2); ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.balance (transaction, send1.hash ())); ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, send1.hash ())); - ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.weight (transaction, nano::genesis_account)); + ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::genesis_account)); nano::state_block receive1 (nano::genesis_account, send1.hash (), nano::genesis_account, nano::genesis_amount, send1.hash (), nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (send1.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, receive1).code); ASSERT_TRUE (store->block_exists (transaction, receive1.hash ())); @@ -1722,7 +1723,7 @@ TEST (ledger, state_receive) ASSERT_EQ (receive1, *receive2); ASSERT_EQ (nano::genesis_amount, ledger.balance (transaction, receive1.hash ())); ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, receive1.hash ())); - ASSERT_EQ (nano::genesis_amount, ledger.weight (transaction, nano::genesis_account)); + ASSERT_EQ (nano::genesis_amount, ledger.weight (nano::genesis_account)); } TEST (ledger, state_rep_change) @@ -1734,7 +1735,7 @@ TEST (ledger, state_rep_change) nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); 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 ())); @@ -1745,8 +1746,8 @@ TEST (ledger, state_rep_change) ASSERT_EQ (change1, *change2); ASSERT_EQ (nano::genesis_amount, ledger.balance (transaction, change1.hash ())); ASSERT_EQ (0, ledger.amount (transaction, change1.hash ())); - ASSERT_EQ (0, ledger.weight (transaction, nano::genesis_account)); - ASSERT_EQ (nano::genesis_amount, ledger.weight (transaction, rep.pub)); + ASSERT_EQ (0, ledger.weight (nano::genesis_account)); + ASSERT_EQ (nano::genesis_amount, ledger.weight (rep.pub)); } TEST (ledger, state_open) @@ -1758,7 +1759,7 @@ TEST (ledger, state_open) nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); 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 ())); @@ -1769,7 +1770,7 @@ TEST (ledger, state_open) ASSERT_EQ (send1, *send2); ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.balance (transaction, send1.hash ())); ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, send1.hash ())); - ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.weight (transaction, nano::genesis_account)); + ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::genesis_account)); ASSERT_TRUE (store->pending_exists (transaction, nano::pending_key (destination.pub, send1.hash ()))); nano::state_block open1 (destination.pub, 0, nano::genesis_account, nano::Gxrb_ratio, send1.hash (), destination.prv, destination.pub, pool.generate (destination.pub)); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, open1).code); @@ -1780,7 +1781,7 @@ TEST (ledger, state_open) ASSERT_EQ (open1, *open2); ASSERT_EQ (nano::Gxrb_ratio, ledger.balance (transaction, open1.hash ())); ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, open1.hash ())); - ASSERT_EQ (nano::genesis_amount, ledger.weight (transaction, nano::genesis_account)); + ASSERT_EQ (nano::genesis_amount, ledger.weight (nano::genesis_account)); } // Make sure old block types can't be inserted after a state block. @@ -1793,7 +1794,7 @@ TEST (ledger, send_after_state_fail) nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); nano::work_pool pool (std::numeric_limits::max ()); nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::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); @@ -1811,7 +1812,7 @@ TEST (ledger, receive_after_state_fail) nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); nano::work_pool pool (std::numeric_limits::max ()); nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::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); @@ -1829,7 +1830,7 @@ TEST (ledger, change_after_state_fail) nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); nano::work_pool pool (std::numeric_limits::max ()); nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::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); @@ -1847,7 +1848,7 @@ TEST (ledger, state_unreceivable_fail) nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); 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); @@ -1857,7 +1858,7 @@ TEST (ledger, state_unreceivable_fail) ASSERT_EQ (send1, *send2); ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.balance (transaction, send1.hash ())); ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, send1.hash ())); - ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.weight (transaction, nano::genesis_account)); + ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::genesis_account)); nano::state_block receive1 (nano::genesis_account, send1.hash (), nano::genesis_account, nano::genesis_amount, 1, nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (send1.hash ())); ASSERT_EQ (nano::process_result::gap_source, ledger.process (transaction, receive1).code); } @@ -1871,7 +1872,7 @@ TEST (ledger, state_receive_bad_amount_fail) nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); 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); @@ -1881,7 +1882,7 @@ TEST (ledger, state_receive_bad_amount_fail) ASSERT_EQ (send1, *send2); ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.balance (transaction, send1.hash ())); ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, send1.hash ())); - ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.weight (transaction, nano::genesis_account)); + ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::genesis_account)); nano::state_block receive1 (nano::genesis_account, send1.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, send1.hash (), nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (send1.hash ())); ASSERT_EQ (nano::process_result::balance_mismatch, ledger.process (transaction, receive1).code); } @@ -1895,7 +1896,7 @@ TEST (ledger, state_no_link_amount_fail) nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); nano::work_pool pool (std::numeric_limits::max ()); nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::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); @@ -1913,7 +1914,7 @@ TEST (ledger, state_receive_wrong_account_fail) nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); nano::work_pool pool (std::numeric_limits::max ()); nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::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); @@ -1923,7 +1924,7 @@ TEST (ledger, state_receive_wrong_account_fail) ASSERT_EQ (send1, *send2); ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.balance (transaction, send1.hash ())); ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, send1.hash ())); - ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.weight (transaction, nano::genesis_account)); + ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::genesis_account)); nano::keypair key; nano::state_block receive1 (key.pub, 0, nano::genesis_account, nano::Gxrb_ratio, send1.hash (), key.prv, key.pub, pool.generate (key.pub)); ASSERT_EQ (nano::process_result::unreceivable, ledger.process (transaction, receive1).code); @@ -1938,7 +1939,7 @@ TEST (ledger, state_open_state_fork) nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); 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 ())); @@ -1959,7 +1960,7 @@ TEST (ledger, state_state_open_fork) nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); 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 ())); @@ -1980,7 +1981,7 @@ TEST (ledger, state_open_previous_fail) nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); 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 ())); @@ -1998,7 +1999,7 @@ TEST (ledger, state_open_source_fail) nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); 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 ())); @@ -2016,7 +2017,7 @@ TEST (ledger, state_send_change) nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); 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 ())); @@ -2027,8 +2028,8 @@ TEST (ledger, state_send_change) ASSERT_EQ (send1, *send2); ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.balance (transaction, send1.hash ())); ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, send1.hash ())); - ASSERT_EQ (0, ledger.weight (transaction, nano::genesis_account)); - ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.weight (transaction, rep.pub)); + ASSERT_EQ (0, ledger.weight (nano::genesis_account)); + ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.weight (rep.pub)); } TEST (ledger, state_receive_change) @@ -2040,7 +2041,7 @@ TEST (ledger, state_receive_change) nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); nano::work_pool pool (std::numeric_limits::max ()); nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::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); @@ -2050,7 +2051,7 @@ TEST (ledger, state_receive_change) ASSERT_EQ (send1, *send2); ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.balance (transaction, send1.hash ())); ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, send1.hash ())); - ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.weight (transaction, nano::genesis_account)); + ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::genesis_account)); nano::keypair rep; nano::state_block receive1 (nano::genesis_account, send1.hash (), rep.pub, nano::genesis_amount, send1.hash (), nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (send1.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, receive1).code); @@ -2060,8 +2061,8 @@ TEST (ledger, state_receive_change) ASSERT_EQ (receive1, *receive2); ASSERT_EQ (nano::genesis_amount, ledger.balance (transaction, receive1.hash ())); ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, receive1.hash ())); - ASSERT_EQ (0, ledger.weight (transaction, nano::genesis_account)); - ASSERT_EQ (nano::genesis_amount, ledger.weight (transaction, rep.pub)); + ASSERT_EQ (0, ledger.weight (nano::genesis_account)); + ASSERT_EQ (nano::genesis_amount, ledger.weight (rep.pub)); } TEST (ledger, state_open_old) @@ -2073,7 +2074,7 @@ TEST (ledger, state_open_old) nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); 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 ())); @@ -2082,7 +2083,7 @@ TEST (ledger, state_open_old) ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, open1).code); ASSERT_EQ (nano::Gxrb_ratio, ledger.balance (transaction, open1.hash ())); ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, open1.hash ())); - ASSERT_EQ (nano::genesis_amount, ledger.weight (transaction, nano::genesis_account)); + ASSERT_EQ (nano::genesis_amount, ledger.weight (nano::genesis_account)); } TEST (ledger, state_receive_old) @@ -2094,7 +2095,7 @@ TEST (ledger, state_receive_old) nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); 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 ())); @@ -2107,7 +2108,7 @@ TEST (ledger, state_receive_old) ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, receive1).code); ASSERT_EQ (2 * nano::Gxrb_ratio, ledger.balance (transaction, receive1.hash ())); ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, receive1.hash ())); - ASSERT_EQ (nano::genesis_amount, ledger.weight (transaction, nano::genesis_account)); + ASSERT_EQ (nano::genesis_amount, ledger.weight (nano::genesis_account)); } TEST (ledger, state_rollback_send) @@ -2119,7 +2120,7 @@ TEST (ledger, state_rollback_send) nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); nano::work_pool pool (std::numeric_limits::max ()); nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::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); @@ -2128,7 +2129,7 @@ TEST (ledger, state_rollback_send) ASSERT_NE (nullptr, send2); ASSERT_EQ (send1, *send2); ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.account_balance (transaction, nano::genesis_account)); - ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.weight (transaction, nano::genesis_account)); + ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::genesis_account)); nano::pending_info info; ASSERT_FALSE (store->pending_get (transaction, nano::pending_key (nano::genesis_account, send1.hash ()), info)); ASSERT_EQ (nano::genesis_account, info.source); @@ -2136,7 +2137,7 @@ TEST (ledger, state_rollback_send) ASSERT_FALSE (ledger.rollback (transaction, send1.hash ())); ASSERT_FALSE (store->block_exists (transaction, send1.hash ())); ASSERT_EQ (nano::genesis_amount, ledger.account_balance (transaction, nano::genesis_account)); - ASSERT_EQ (nano::genesis_amount, ledger.weight (transaction, nano::genesis_account)); + ASSERT_EQ (nano::genesis_amount, ledger.weight (nano::genesis_account)); ASSERT_FALSE (store->pending_exists (transaction, nano::pending_key (nano::genesis_account, send1.hash ()))); ASSERT_TRUE (store->block_successor (transaction, genesis.hash ()).is_zero ()); } @@ -2150,7 +2151,7 @@ TEST (ledger, state_rollback_receive) nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); nano::work_pool pool (std::numeric_limits::max ()); nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::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); @@ -2164,7 +2165,7 @@ TEST (ledger, state_rollback_receive) ASSERT_EQ (nano::Gxrb_ratio, info.amount.number ()); ASSERT_FALSE (store->block_exists (transaction, receive1.hash ())); ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.account_balance (transaction, nano::genesis_account)); - ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.weight (transaction, nano::genesis_account)); + ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::genesis_account)); } TEST (ledger, state_rollback_received_send) @@ -2176,7 +2177,7 @@ TEST (ledger, state_rollback_received_send) nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); 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 ())); @@ -2189,9 +2190,9 @@ TEST (ledger, state_rollback_received_send) ASSERT_FALSE (store->block_exists (transaction, send1.hash ())); ASSERT_FALSE (store->block_exists (transaction, receive1.hash ())); ASSERT_EQ (nano::genesis_amount, ledger.account_balance (transaction, nano::genesis_account)); - ASSERT_EQ (nano::genesis_amount, ledger.weight (transaction, nano::genesis_account)); + ASSERT_EQ (nano::genesis_amount, ledger.weight (nano::genesis_account)); ASSERT_EQ (0, ledger.account_balance (transaction, key.pub)); - ASSERT_EQ (0, ledger.weight (transaction, key.pub)); + ASSERT_EQ (0, ledger.weight (key.pub)); } TEST (ledger, state_rep_change_rollback) @@ -2203,7 +2204,7 @@ TEST (ledger, state_rep_change_rollback) nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); 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 ())); @@ -2211,8 +2212,8 @@ TEST (ledger, state_rep_change_rollback) ASSERT_FALSE (ledger.rollback (transaction, change1.hash ())); ASSERT_FALSE (store->block_exists (transaction, change1.hash ())); ASSERT_EQ (nano::genesis_amount, ledger.account_balance (transaction, nano::genesis_account)); - ASSERT_EQ (nano::genesis_amount, ledger.weight (transaction, nano::genesis_account)); - ASSERT_EQ (0, ledger.weight (transaction, rep.pub)); + ASSERT_EQ (nano::genesis_amount, ledger.weight (nano::genesis_account)); + ASSERT_EQ (0, ledger.weight (rep.pub)); } TEST (ledger, state_open_rollback) @@ -2224,7 +2225,7 @@ TEST (ledger, state_open_rollback) nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); 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 ())); @@ -2234,7 +2235,7 @@ TEST (ledger, state_open_rollback) ASSERT_FALSE (ledger.rollback (transaction, open1.hash ())); ASSERT_FALSE (store->block_exists (transaction, open1.hash ())); ASSERT_EQ (0, ledger.account_balance (transaction, destination.pub)); - ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.weight (transaction, nano::genesis_account)); + ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::genesis_account)); nano::pending_info info; ASSERT_FALSE (store->pending_get (transaction, nano::pending_key (destination.pub, send1.hash ()), info)); ASSERT_EQ (nano::genesis_account, info.source); @@ -2250,7 +2251,7 @@ TEST (ledger, state_send_change_rollback) nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); 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 ())); @@ -2258,8 +2259,8 @@ TEST (ledger, state_send_change_rollback) ASSERT_FALSE (ledger.rollback (transaction, send1.hash ())); ASSERT_FALSE (store->block_exists (transaction, send1.hash ())); ASSERT_EQ (nano::genesis_amount, ledger.account_balance (transaction, nano::genesis_account)); - ASSERT_EQ (nano::genesis_amount, ledger.weight (transaction, nano::genesis_account)); - ASSERT_EQ (0, ledger.weight (transaction, rep.pub)); + ASSERT_EQ (nano::genesis_amount, ledger.weight (nano::genesis_account)); + ASSERT_EQ (0, ledger.weight (rep.pub)); } TEST (ledger, state_receive_change_rollback) @@ -2271,7 +2272,7 @@ TEST (ledger, state_receive_change_rollback) nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); nano::work_pool pool (std::numeric_limits::max ()); nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::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); @@ -2281,8 +2282,8 @@ TEST (ledger, state_receive_change_rollback) ASSERT_FALSE (ledger.rollback (transaction, receive1.hash ())); ASSERT_FALSE (store->block_exists (transaction, receive1.hash ())); ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.account_balance (transaction, nano::genesis_account)); - ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.weight (transaction, nano::genesis_account)); - ASSERT_EQ (0, ledger.weight (transaction, rep.pub)); + ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::genesis_account)); + ASSERT_EQ (0, ledger.weight (rep.pub)); } TEST (ledger, epoch_blocks_general) @@ -2294,7 +2295,7 @@ TEST (ledger, epoch_blocks_general) nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); 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, ledger.link (nano::epoch::epoch_1), nano::test_genesis_key.prv, nano::test_genesis_key.pub, pool.generate (genesis.hash ())); @@ -2327,8 +2328,8 @@ TEST (ledger, epoch_blocks_general) ASSERT_EQ (0, ledger.balance (transaction, epoch4.hash ())); ASSERT_EQ (nano::Gxrb_ratio, ledger.balance (transaction, receive2.hash ())); ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, receive2.hash ())); - ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.weight (transaction, nano::genesis_account)); - ASSERT_EQ (nano::Gxrb_ratio, ledger.weight (transaction, destination.pub)); + ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::genesis_account)); + ASSERT_EQ (nano::Gxrb_ratio, ledger.weight (destination.pub)); } TEST (ledger, epoch_blocks_receive_upgrade) @@ -2340,7 +2341,7 @@ TEST (ledger, epoch_blocks_receive_upgrade) nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); 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 ())); @@ -2380,7 +2381,7 @@ TEST (ledger, epoch_blocks_fork) nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); 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 ())); @@ -2488,10 +2489,10 @@ TEST (ledger, block_hash_account_conflict) auto votes2 (node1.active.roots.find (receive1->qualified_root ())->election); auto votes3 (node1.active.roots.find (send2->qualified_root ())->election); auto votes4 (node1.active.roots.find (open_epoch1->qualified_root ())->election); - auto winner1 (*votes1->tally (transaction).begin ()); - auto winner2 (*votes2->tally (transaction).begin ()); - auto winner3 (*votes3->tally (transaction).begin ()); - auto winner4 (*votes4->tally (transaction).begin ()); + auto winner1 (*votes1->tally ().begin ()); + auto winner2 (*votes2->tally ().begin ()); + auto winner3 (*votes3->tally ().begin ()); + auto winner4 (*votes4->tally ().begin ()); ASSERT_EQ (*send1, *winner1.second); ASSERT_EQ (*receive1, *winner2.second); ASSERT_EQ (*send2, *winner3.second); @@ -2507,7 +2508,7 @@ TEST (ledger, could_fit) nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); nano::work_pool pool (std::numeric_limits::max ()); nano::keypair destination; // Test legacy and state change blocks could_fit @@ -2733,7 +2734,7 @@ TEST (ledger, confirmation_height_not_updated) nano::ledger ledger (*store, stats); auto transaction (store->tx_begin_write ()); nano::genesis genesis; - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); 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 b091f0ca3d..fa6e87d69e 100644 --- a/nano/core_test/network.cpp +++ b/nano/core_test/network.cpp @@ -2118,7 +2118,7 @@ TEST (confirmation_height, conflict_rollback_cemented) auto transaction1 (system.nodes[0]->store.tx_begin_read ()); auto transaction2 (system.nodes[1]->store.tx_begin_read ()); lock.lock (); - auto winner (*votes1->tally (transaction2).begin ()); + auto winner (*votes1->tally ().begin ()); ASSERT_EQ (*publish1.block, *winner.second); ASSERT_EQ (nano::genesis_amount - 100, winner.first); ASSERT_TRUE (node1.store.block_exists (transaction1, publish1.block->hash ())); diff --git a/nano/core_test/node.cpp b/nano/core_test/node.cpp index aaf01cff43..92e5434c30 100644 --- a/nano/core_test/node.cpp +++ b/nano/core_test/node.cpp @@ -253,7 +253,7 @@ TEST (node, auto_bootstrap) while (node1->bootstrap_initiator.in_progress ()) { ASSERT_NO_ERROR (system.poll ()); - }; + } system.deadline_set (5s); while (node1->stats.count (nano::stat::type::observer, nano::stat::detail::observer_confirmation_active_quorum, nano::stat::dir::out) + node1->stats.count (nano::stat::type::observer, nano::stat::detail::observer_confirmation_active_conf_height, nano::stat::dir::out) < 2) { @@ -1146,7 +1146,7 @@ TEST (node, fork_publish) ASSERT_NE (election->last_votes.end (), existing1); ASSERT_EQ (send1->hash (), existing1->second.hash); auto transaction (node1.store.tx_begin_read ()); - auto winner (*election->tally (transaction).begin ()); + auto winner (*election->tally ().begin ()); ASSERT_EQ (*send1, *winner.second); ASSERT_EQ (nano::genesis_amount - 100, winner.first); } @@ -1199,7 +1199,7 @@ TEST (node, fork_keep) auto transaction1 (system.nodes[1]->store.tx_begin_read ()); // The vote should be in agreement with what we already have. lock.lock (); - auto winner (*votes1->tally (transaction1).begin ()); + auto winner (*votes1->tally ().begin ()); ASSERT_EQ (*send1, *winner.second); ASSERT_EQ (nano::genesis_amount - 100, winner.first); ASSERT_TRUE (system.nodes[0]->store.block_exists (transaction0, send1->hash ())); @@ -1257,7 +1257,7 @@ TEST (node, fork_flip) auto transaction1 (system.nodes[0]->store.tx_begin_read ()); auto transaction2 (system.nodes[1]->store.tx_begin_read ()); lock.lock (); - auto winner (*votes1->tally (transaction2).begin ()); + auto winner (*votes1->tally ().begin ()); ASSERT_EQ (*publish1.block, *winner.second); ASSERT_EQ (nano::genesis_amount - 100, winner.first); ASSERT_TRUE (node1.store.block_exists (transaction1, publish1.block->hash ())); @@ -1319,7 +1319,7 @@ TEST (node, fork_multi_flip) auto transaction1 (system.nodes[0]->store.tx_begin_read ()); auto transaction2 (system.nodes[1]->store.tx_begin_read ()); lock.lock (); - auto winner (*votes1->tally (transaction2).begin ()); + auto winner (*votes1->tally ().begin ()); ASSERT_EQ (*publish1.block, *winner.second); ASSERT_EQ (nano::genesis_amount - 100, winner.first); ASSERT_TRUE (node1.store.block_exists (transaction1, publish1.block->hash ())); @@ -1445,7 +1445,7 @@ TEST (node, fork_open_flip) auto transaction1 (system.nodes[0]->store.tx_begin_read ()); auto transaction2 (system.nodes[1]->store.tx_begin_read ()); lock.lock (); - auto winner (*votes1->tally (transaction2).begin ()); + auto winner (*votes1->tally ().begin ()); ASSERT_EQ (*open1, *winner.second); ASSERT_EQ (nano::genesis_amount - 1, winner.first); ASSERT_TRUE (node1.store.block_exists (transaction1, open1->hash ())); @@ -2475,7 +2475,7 @@ TEST (node, vote_by_hash_bundle) system.wallet (0)->insert_adhoc (key1.prv); std::atomic max_hashes{ 0 }; - system.nodes[0]->observers.vote.add ([&max_hashes](nano::transaction const & transaction, std::shared_ptr vote_a, std::shared_ptr channel_a) { + system.nodes[0]->observers.vote.add ([&max_hashes](std::shared_ptr vote_a, std::shared_ptr channel_a) { if (vote_a->blocks.size () > max_hashes) { max_hashes = vote_a->blocks.size (); @@ -3055,8 +3055,9 @@ TEST (node, dont_write_lock_node) nano::genesis genesis; nano::rep_weights rep_weights; std::atomic cemented_count{ 0 }; + std::atomic block_count_cache{ 0 }; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, rep_weights, cemented_count); + store->initialize (transaction, genesis, rep_weights, cemented_count, block_count_cache); } // 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 dbf48c7c91..28a4eb364c 100644 --- a/nano/core_test/processor_service.cpp +++ b/nano/core_test/processor_service.cpp @@ -17,7 +17,7 @@ TEST (processor_service, bad_send_signature) nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); nano::work_pool pool (std::numeric_limits::max ()); nano::account_info info1; ASSERT_FALSE (store->account_get (transaction, nano::test_genesis_key.pub, info1)); @@ -36,7 +36,7 @@ TEST (processor_service, bad_receive_signature) nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); 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/node/active_transactions.cpp b/nano/node/active_transactions.cpp index 1ece285ca9..6439dcd52e 100644 --- a/nano/node/active_transactions.cpp +++ b/nano/node/active_transactions.cpp @@ -120,7 +120,7 @@ void nano::active_transactions::request_confirm (nano::unique_lock & /* Confirm frontiers when there aren't many confirmations already pending and node finished initial bootstrap In auto mode start confirm only if node contains almost principal representative (half of required for principal weight) */ lock_a.unlock (); - if (node.config.frontiers_confirmation != nano::frontiers_confirmation_mode::disabled && node.pending_confirmation_height.size () < confirmed_frontiers_max_pending_cut_off && node.store.block_count (transaction).sum () >= node.ledger.bootstrap_weight_max_blocks) + if (node.config.frontiers_confirmation != nano::frontiers_confirmation_mode::disabled && node.pending_confirmation_height.size () < confirmed_frontiers_max_pending_cut_off && node.ledger.block_count_cache >= node.ledger.bootstrap_weight_max_blocks) { confirm_frontiers (transaction); } @@ -147,7 +147,7 @@ void nano::active_transactions::request_confirm (nano::unique_lock & // Log votes for very long unconfirmed elections if (election_l->confirmation_request_count % 50 == 1) { - auto tally_l (election_l->tally (transaction)); + auto tally_l (election_l->tally ()); election_l->log_votes (tally_l); } /* Escalation for long unconfirmed elections @@ -931,10 +931,8 @@ size_t nano::active_transactions::inactive_votes_cache_size () void nano::active_transactions::add_inactive_votes_cache (nano::block_hash const & hash_a, nano::account const & representative_a) { - /* Check principal representative status - nano::ledger::weight (...) call is too expensive due to read transaction requirements - Replace with nano::ledger::weight (...) after proper changes */ - if (node.ledger.rep_weights.representation_get (representative_a) > node.minimum_principal_weight ()) + // Check principal representative status + if (node.ledger.weight (representative_a) > node.minimum_principal_weight ()) { auto existing (inactive_votes_cache.get<1> ().find (hash_a)); if (existing != inactive_votes_cache.get<1> ().end ()) @@ -952,8 +950,7 @@ void nano::active_transactions::add_inactive_votes_cache (nano::block_hash const if (is_new) { - auto transaction (node.store.tx_begin_read ()); - node.gap_cache.bootstrap_check (transaction, existing->voters, hash_a); + node.gap_cache.bootstrap_check (existing->voters, hash_a); } } else diff --git a/nano/node/bootstrap/bootstrap.cpp b/nano/node/bootstrap/bootstrap.cpp index af0f2b9602..641fb69e8c 100644 --- a/nano/node/bootstrap/bootstrap.cpp +++ b/nano/node/bootstrap/bootstrap.cpp @@ -256,10 +256,7 @@ void nano::bootstrap_attempt::run () lazy_run (); lock.lock (); } - if (!node->flags.disable_unchecked_cleanup) - { - node->unchecked_cleanup (); - } + node->unchecked_cleanup (); } stopped = true; condition.notify_all (); diff --git a/nano/node/election.cpp b/nano/node/election.cpp index 6b2c45dc45..7d26257946 100644 --- a/nano/node/election.cpp +++ b/nano/node/election.cpp @@ -25,7 +25,7 @@ void nano::election::compute_rep_votes (nano::transaction const & transaction_a) { if (node.config.enable_voting) { - node.wallets.foreach_representative (transaction_a, [this, &transaction_a](nano::public_key const & pub_a, nano::raw_key const & prv_a) { + node.wallets.foreach_representative ([this, &transaction_a](nano::public_key const & pub_a, nano::raw_key const & prv_a) { auto vote (this->node.store.vote_generate (transaction_a, pub_a, prv_a, status.winner)); this->node.vote_processor.vote (vote, std::make_shared (this->node.network.udp_channels, this->node.network.endpoint (), this->node.network_params.protocol.protocol_version)); }); @@ -83,12 +83,12 @@ bool nano::election::have_quorum (nano::tally_t const & tally_a, nano::uint128_t return result; } -nano::tally_t nano::election::tally (nano::transaction const & transaction_a) +nano::tally_t nano::election::tally () { std::unordered_map block_weights; for (auto vote_info : last_votes) { - block_weights[vote_info.second.hash] += node.ledger.weight (transaction_a, vote_info.first); + block_weights[vote_info.second.hash] += node.ledger.weight (vote_info.first); } last_tally = block_weights; nano::tally_t result; @@ -103,9 +103,9 @@ nano::tally_t nano::election::tally (nano::transaction const & transaction_a) return result; } -void nano::election::confirm_if_quorum (nano::transaction const & transaction_a) +void nano::election::confirm_if_quorum () { - auto tally_l (tally (transaction_a)); + auto tally_l (tally ()); assert (!tally_l.empty ()); auto winner (tally_l.begin ()); auto block_l (winner->second); @@ -152,10 +152,9 @@ void nano::election::log_votes (nano::tally_t const & tally_a) const nano::election_vote_result nano::election::vote (nano::account rep, uint64_t sequence, nano::block_hash block_hash) { // see republish_vote documentation for an explanation of these rules - auto transaction (node.store.tx_begin_read ()); auto replay (false); auto online_stake (node.online_reps.online_stake ()); - auto weight (node.ledger.weight (transaction, rep)); + auto weight (node.ledger.weight (rep)); auto should_process (false); if (node.network_params.network.is_test_network () || weight > node.minimum_principal_weight (online_stake)) { @@ -198,7 +197,7 @@ nano::election_vote_result nano::election::vote (nano::account rep, uint64_t seq last_votes[rep] = { std::chrono::steady_clock::now (), sequence, block_hash }; if (!confirmed) { - confirm_if_quorum (transaction); + confirm_if_quorum (); } } } @@ -224,7 +223,7 @@ bool nano::election::publish (std::shared_ptr block_a) if (blocks.find (block_a->hash ()) == blocks.end ()) { blocks.insert (std::make_pair (block_a->hash (), block_a)); - confirm_if_quorum (transaction); + confirm_if_quorum (); node.network.flood_block (block_a, false); } else @@ -321,7 +320,6 @@ void nano::election::insert_inactive_votes_cache () node.stats.inc (nano::stat::type::election, nano::stat::detail::late_block); node.stats.add (nano::stat::type::election, nano::stat::detail::late_block_seconds, nano::stat::dir::in, delay.count (), true); } - auto transaction (node.store.tx_begin_read ()); - confirm_if_quorum (transaction); + confirm_if_quorum (); } } diff --git a/nano/node/election.hpp b/nano/node/election.hpp index 9243f65e3a..5a5f37f16c 100644 --- a/nano/node/election.hpp +++ b/nano/node/election.hpp @@ -36,14 +36,14 @@ class election final : public std::enable_shared_from_this public: election (nano::node &, std::shared_ptr, std::function)> const &); nano::election_vote_result vote (nano::account, uint64_t, nano::block_hash); - nano::tally_t tally (nano::transaction const &); + nano::tally_t tally (); // Check if we have vote quorum bool have_quorum (nano::tally_t const &, nano::uint128_t) const; // Change our winner to agree with the network void compute_rep_votes (nano::transaction const &); void confirm_once (nano::election_status_type = nano::election_status_type::active_confirmed_quorum); // Confirm this block if quorum is met - void confirm_if_quorum (nano::transaction const &); + void confirm_if_quorum (); void log_votes (nano::tally_t const &) const; bool publish (std::shared_ptr block_a); size_t last_votes_size (); diff --git a/nano/node/gap_cache.cpp b/nano/node/gap_cache.cpp index 61d8e8e2bb..8a093ff8a9 100644 --- a/nano/node/gap_cache.cpp +++ b/nano/node/gap_cache.cpp @@ -36,7 +36,6 @@ void nano::gap_cache::erase (nano::block_hash const & hash_a) void nano::gap_cache::vote (std::shared_ptr vote_a) { nano::lock_guard lock (mutex); - auto transaction (node.store.tx_begin_read ()); for (auto hash : *vote_a) { auto existing (blocks.get<1> ().find (hash)); @@ -54,18 +53,18 @@ void nano::gap_cache::vote (std::shared_ptr vote_a) if (is_new) { - bootstrap_check (transaction, existing->voters, hash); + bootstrap_check (existing->voters, hash); } } } } -void nano::gap_cache::bootstrap_check (nano::transaction const & transaction_a, std::vector const & voters_a, nano::block_hash const & hash_a) +void nano::gap_cache::bootstrap_check (std::vector const & voters_a, nano::block_hash const & hash_a) { uint128_t tally; for (auto & voter : voters_a) { - tally += node.ledger.weight (transaction_a, voter); + tally += node.ledger.weight (voter); } bool start_bootstrap (false); if (!node.flags.disable_lazy_bootstrap) @@ -75,7 +74,7 @@ void nano::gap_cache::bootstrap_check (nano::transaction const & transaction_a, start_bootstrap = true; } } - else if (!node.flags.disable_legacy_bootstrap && tally > bootstrap_threshold (transaction_a)) + else if (!node.flags.disable_legacy_bootstrap && tally > bootstrap_threshold ()) { start_bootstrap = true; } @@ -104,7 +103,7 @@ void nano::gap_cache::bootstrap_check (nano::transaction const & transaction_a, } } -nano::uint128_t nano::gap_cache::bootstrap_threshold (nano::transaction const & transaction_a) +nano::uint128_t nano::gap_cache::bootstrap_threshold () { auto result ((node.online_reps.online_stake () / 256) * node.config.bootstrap_fraction_numerator); return result; diff --git a/nano/node/gap_cache.hpp b/nano/node/gap_cache.hpp index 9dd42f53b4..838000de24 100644 --- a/nano/node/gap_cache.hpp +++ b/nano/node/gap_cache.hpp @@ -37,8 +37,8 @@ class gap_cache final void add (nano::block_hash const &, std::chrono::steady_clock::time_point = std::chrono::steady_clock::now ()); void erase (nano::block_hash const & hash_a); void vote (std::shared_ptr); - void bootstrap_check (nano::transaction const &, std::vector const &, nano::block_hash const &); - nano::uint128_t bootstrap_threshold (nano::transaction const &); + void bootstrap_check (std::vector const &, nano::block_hash const &); + nano::uint128_t bootstrap_threshold (); size_t size (); boost::multi_index_container< nano::gap_information, diff --git a/nano/node/json_handler.cpp b/nano/node/json_handler.cpp index c9c076d4b6..d94836dde9 100644 --- a/nano/node/json_handler.cpp +++ b/nano/node/json_handler.cpp @@ -542,7 +542,7 @@ void nano::json_handler::account_info () } if (weight) { - auto account_weight (node.ledger.weight (transaction, account)); + auto account_weight (node.ledger.weight (account)); response_l.put ("weight", account_weight.convert_to ()); } if (pending) @@ -1812,8 +1812,7 @@ void nano::json_handler::confirmation_info () auto election (conflict_info->election); nano::uint128_t total (0); response_l.put ("last_winner", election->status.winner->hash ().to_string ()); - auto transaction (node.store.tx_begin_read ()); - auto tally_l (election->tally (transaction)); + auto tally_l (election->tally ()); boost::property_tree::ptree blocks; for (auto i (tally_l.begin ()), n (tally_l.end ()); i != n; ++i) { @@ -2433,7 +2432,7 @@ void nano::json_handler::ledger () } if (weight) { - auto account_weight (node.ledger.weight (transaction, account)); + auto account_weight (node.ledger.weight (account)); response_a.put ("weight", account_weight.convert_to ()); } accounts.push_back (std::make_pair (account.to_account (), response_a)); @@ -2485,7 +2484,7 @@ void nano::json_handler::ledger () } if (weight) { - auto account_weight (node.ledger.weight (transaction, account)); + auto account_weight (node.ledger.weight (account)); response_a.put ("weight", account_weight.convert_to ()); } accounts.push_back (std::make_pair (account.to_account (), response_a)); @@ -3229,7 +3228,6 @@ void nano::json_handler::representatives_online () if (!ec) { boost::property_tree::ptree representatives; - auto transaction (node.store.tx_begin_read ()); auto reps (node.online_reps.list ()); for (auto & i : reps) { @@ -3252,7 +3250,7 @@ void nano::json_handler::representatives_online () if (weight) { boost::property_tree::ptree weight_node; - auto account_weight (node.ledger.weight (transaction, i)); + auto account_weight (node.ledger.weight (i)); weight_node.put ("weight", account_weight.convert_to ()); representatives.add_child (i.to_account (), weight_node); } @@ -4236,7 +4234,7 @@ void nano::json_handler::wallet_ledger () } if (weight) { - auto account_weight (node.ledger.weight (block_transaction, account)); + auto account_weight (node.ledger.weight (account)); entry.put ("weight", account_weight.convert_to ()); } if (pending) diff --git a/nano/node/network.cpp b/nano/node/network.cpp index 7a9916a086..008514eb8a 100644 --- a/nano/node/network.cpp +++ b/nano/node/network.cpp @@ -139,7 +139,7 @@ bool confirm_block (nano::transaction const & transaction_a, nano::node & node_a if (votes.empty ()) { // Generate new vote - node_a.wallets.foreach_representative (transaction_a, [&result, &list_a, &node_a, &transaction_a, &hash](nano::public_key const & pub_a, nano::raw_key const & prv_a) { + node_a.wallets.foreach_representative ([&result, &list_a, &node_a, &transaction_a, &hash](nano::public_key const & pub_a, nano::raw_key const & prv_a) { result = true; auto vote (node_a.store.vote_generate (transaction_a, pub_a, prv_a, std::vector (1, hash))); nano::confirm_ack confirm (vote); @@ -186,7 +186,7 @@ void nano::network::confirm_hashes (nano::transaction const & transaction_a, std { if (node.config.enable_voting) { - node.wallets.foreach_representative (transaction_a, [this, &blocks_bundle_a, &channel_a, &transaction_a](nano::public_key const & pub_a, nano::raw_key const & prv_a) { + node.wallets.foreach_representative ([this, &blocks_bundle_a, &channel_a, &transaction_a](nano::public_key const & pub_a, nano::raw_key const & prv_a) { auto vote (this->node.store.vote_generate (transaction_a, pub_a, prv_a, blocks_bundle_a)); nano::confirm_ack confirm (vote); std::shared_ptr> bytes (new std::vector); diff --git a/nano/node/node.cpp b/nano/node/node.cpp index 3a6f49e5ee..c8eadc20a6 100644 --- a/nano/node/node.cpp +++ b/nano/node/node.cpp @@ -309,12 +309,12 @@ startup_time (std::chrono::steady_clock::now ()) this->network.send_keepalive_self (channel_a); } }); - observers.vote.add ([this](nano::transaction const & transaction, std::shared_ptr vote_a, std::shared_ptr channel_a) { + observers.vote.add ([this](std::shared_ptr vote_a, std::shared_ptr channel_a) { this->gap_cache.vote (vote_a); this->online_reps.observe (vote_a->account); nano::uint128_t rep_weight; { - rep_weight = ledger.weight (transaction, vote_a->account); + rep_weight = ledger.weight (vote_a->account); } if (rep_weight > minimum_principal_weight ()) { @@ -349,7 +349,7 @@ startup_time (std::chrono::steady_clock::now ()) }); if (websocket_server) { - observers.vote.add ([this](nano::transaction const & transaction, std::shared_ptr vote_a, std::shared_ptr channel_a) { + observers.vote.add ([this](std::shared_ptr vote_a, std::shared_ptr channel_a) { if (this->websocket_server->any_subscriber (nano::websocket::topic::vote)) { nano::websocket::message_builder builder; @@ -397,11 +397,10 @@ 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, ledger.rep_weights, ledger.cemented_count); + store.initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); } - auto transaction (store.tx_begin_read ()); - if (!store.block_exists (transaction, genesis.hash ())) + if (!ledger.block_exists (genesis.hash ())) { std::stringstream ss; ss << "Genesis block not found. Make sure the node network ID is correct."; @@ -430,8 +429,7 @@ startup_time (std::chrono::steady_clock::now ()) if (!nano::try_read (weight_stream, block_height)) { auto max_blocks = (uint64_t)block_height.number (); - auto transaction (store.tx_begin_read ()); - use_bootstrap_weight = ledger.store.block_count (transaction).sum () < max_blocks; + use_bootstrap_weight = ledger.block_count_cache < max_blocks; if (use_bootstrap_weight) { ledger.bootstrap_weight_max_blocks = max_blocks; @@ -751,8 +749,7 @@ std::pair nano::node::balance_pending (nano::a nano::uint128_t nano::node::weight (nano::account const & account_a) { - auto transaction (store.tx_begin_read ()); - return ledger.weight (transaction, account_a); + return ledger.weight (account_a); } nano::block_hash nano::node::rep_block (nano::account const & account_a) @@ -900,6 +897,7 @@ void nano::node::unchecked_cleanup () { std::deque cleaning_list; // Collect old unchecked keys + if (!flags.disable_unchecked_cleanup && ledger.block_count_cache >= ledger.bootstrap_weight_max_blocks) { auto now (nano::seconds_since_epoch ()); auto transaction (store.tx_begin_read ()); @@ -934,7 +932,7 @@ void nano::node::unchecked_cleanup () void nano::node::ongoing_unchecked_cleanup () { - if (!bootstrap_initiator.in_progress () && ledger.block_count () >= ledger.bootstrap_weight_max_blocks) + if (!bootstrap_initiator.in_progress ()) { unchecked_cleanup (); } diff --git a/nano/node/node_observers.hpp b/nano/node/node_observers.hpp index ab9a8a07d4..478e55ec00 100644 --- a/nano/node/node_observers.hpp +++ b/nano/node/node_observers.hpp @@ -15,7 +15,7 @@ class node_observers final using blocks_t = nano::observer_set; blocks_t blocks; nano::observer_set wallet; - nano::observer_set, std::shared_ptr> vote; + nano::observer_set, std::shared_ptr> vote; nano::observer_set active_stopped; nano::observer_set account_balance; nano::observer_set> endpoint; diff --git a/nano/node/online_reps.cpp b/nano/node/online_reps.cpp index b7813bb3c1..cc03cdeabe 100644 --- a/nano/node/online_reps.cpp +++ b/nano/node/online_reps.cpp @@ -16,8 +16,7 @@ minimum (minimum_a) void nano::online_reps::observe (nano::account const & rep_a) { - auto transaction (node.ledger.store.tx_begin_read ()); - if (node.ledger.weight (transaction, rep_a) > 0) + if (node.ledger.weight (rep_a) > 0) { nano::lock_guard lock (mutex); reps.insert (rep_a); @@ -43,7 +42,7 @@ void nano::online_reps::sample () } for (auto & i : reps_copy) { - current += node.ledger.weight (transaction, i); + current += node.ledger.weight (i); } node.ledger.store.online_weight_put (transaction, std::chrono::system_clock::now ().time_since_epoch ().count (), current); auto trend_l (trend (transaction)); diff --git a/nano/node/vote_processor.cpp b/nano/node/vote_processor.cpp index da58bf97a7..d44d64c68c 100644 --- a/nano/node/vote_processor.cpp +++ b/nano/node/vote_processor.cpp @@ -189,7 +189,7 @@ nano::vote_code nano::vote_processor::vote_blocking (nano::transaction const & t switch (result) { case nano::vote_code::vote: - node.observers.vote.notify (transaction_a, vote_a, channel_a); + node.observers.vote.notify (vote_a, channel_a); case nano::vote_code::replay: // This tries to assist rep nodes that have lost track of their highest sequence number by replaying our highest known vote back to them // Only do this if the sequence number is significantly different to account for network reordering @@ -259,12 +259,11 @@ void nano::vote_processor::calculate_weights () representatives_2.clear (); representatives_3.clear (); auto supply (node.online_reps.online_stake ()); - auto transaction (node.store.tx_begin_read ()); auto rep_amounts = node.ledger.rep_weights.get_rep_amounts (); for (auto const & rep_amount : rep_amounts) { nano::account const & representative (rep_amount.first); - auto weight (node.ledger.weight (transaction, representative)); + auto weight (node.ledger.weight (representative)); if (weight > supply / 1000) // 0.1% or above (level 1) { representatives_1.insert (representative); diff --git a/nano/node/voting.cpp b/nano/node/voting.cpp index 3fac7bf2f7..f892db9659 100644 --- a/nano/node/voting.cpp +++ b/nano/node/voting.cpp @@ -48,7 +48,7 @@ void nano::vote_generator::send (nano::unique_lock & lock_a) lock_a.unlock (); { auto transaction (node.store.tx_begin_read ()); - node.wallets.foreach_representative (transaction, [this, &hashes_l, &transaction](nano::public_key const & pub_a, nano::raw_key const & prv_a) { + node.wallets.foreach_representative ([this, &hashes_l, &transaction](nano::public_key const & pub_a, nano::raw_key const & prv_a) { auto vote (this->node.store.vote_generate (transaction, pub_a, prv_a, hashes_l)); this->node.vote_processor.vote (vote, std::make_shared (this->node.network.udp_channels, this->node.network.endpoint (), this->node.network_params.protocol.protocol_version)); this->node.votes_cache.add (vote); diff --git a/nano/node/wallet.cpp b/nano/node/wallet.cpp index 9c6f3033b6..c6fd9a26f6 100644 --- a/nano/node/wallet.cpp +++ b/nano/node/wallet.cpp @@ -809,8 +809,7 @@ nano::public_key nano::wallet::deterministic_insert (nano::transaction const & t work_ensure (key, key); } auto half_principal_weight (wallets.node.minimum_principal_weight () / 2); - auto block_transaction (wallets.node.store.tx_begin_read ()); - if (wallets.check_rep (block_transaction, key, half_principal_weight)) + if (wallets.check_rep (key, half_principal_weight)) { nano::lock_guard lock (representatives_mutex); representatives.insert (key); @@ -853,7 +852,7 @@ nano::public_key nano::wallet::insert_adhoc (nano::transaction const & transacti work_ensure (key, wallets.node.ledger.latest_root (block_transaction, key)); } auto half_principal_weight (wallets.node.minimum_principal_weight () / 2); - if (wallets.check_rep (block_transaction, key, half_principal_weight)) + if (wallets.check_rep (key, half_principal_weight)) { nano::lock_guard lock (representatives_mutex); representatives.insert (key); @@ -1731,7 +1730,7 @@ void nano::wallets::queue_wallet_action (nano::uint128_t const & amount_a, std:: condition.notify_all (); } -void nano::wallets::foreach_representative (nano::transaction const & transaction_a, std::function const & action_a) +void nano::wallets::foreach_representative (std::function const & action_a) { if (node.config.enable_voting) { @@ -1747,7 +1746,7 @@ void nano::wallets::foreach_representative (nano::transaction const & transactio nano::account account (*ii); if (wallet.store.exists (transaction_l, account)) { - if (!node.ledger.weight (transaction_a, account).is_zero ()) + if (!node.ledger.weight (account).is_zero ()) { if (wallet.store.valid_password (transaction_l)) { @@ -1816,10 +1815,10 @@ void nano::wallets::clear_send_ids (nano::transaction const & transaction_a) assert (status == 0); } -bool nano::wallets::check_rep (nano::transaction const & transaction_a, nano::account const & account_a, nano::uint128_t const & half_principal_weight_a) +bool nano::wallets::check_rep (nano::account const & account_a, nano::uint128_t const & half_principal_weight_a) { bool result (false); - auto weight (node.ledger.weight (transaction_a, account_a)); + auto weight (node.ledger.weight (account_a)); if (weight >= node.config.vote_minimum.number ()) { result = true; @@ -1838,7 +1837,6 @@ void nano::wallets::compute_reps () reps_count = 0; half_principal_reps_count = 0; auto half_principal_weight (node.minimum_principal_weight () / 2); - auto ledger_transaction (node.store.tx_begin_read ()); auto transaction (tx_begin_read ()); for (auto i (items.begin ()), n (items.end ()); i != n; ++i) { @@ -1847,7 +1845,7 @@ void nano::wallets::compute_reps () for (auto ii (wallet.store.begin (transaction)), nn (wallet.store.end ()); ii != nn; ++ii) { auto account (ii->first); - if (check_rep (ledger_transaction, account, half_principal_weight)) + if (check_rep (account, half_principal_weight)) { representatives_l.insert (account); } diff --git a/nano/node/wallet.hpp b/nano/node/wallet.hpp index 7875de07b5..7e9c649d48 100644 --- a/nano/node/wallet.hpp +++ b/nano/node/wallet.hpp @@ -196,11 +196,11 @@ class wallets final void reload (); void do_wallet_actions (); void queue_wallet_action (nano::uint128_t const &, std::shared_ptr, std::function const &); - void foreach_representative (nano::transaction const &, std::function const &); + void foreach_representative (std::function const &); bool exists (nano::transaction const &, nano::public_key const &); void stop (); void clear_send_ids (nano::transaction const &); - bool check_rep (nano::transaction const &, nano::account const &, nano::uint128_t const &); + bool check_rep (nano::account const &, nano::uint128_t const &); void compute_reps (); void ongoing_compute_reps (); void split_if_needed (nano::transaction &, nano::block_store &); diff --git a/nano/qt_test/qt.cpp b/nano/qt_test/qt.cpp index e35ea6ed0b..2d428ea97e 100644 --- a/nano/qt_test/qt.cpp +++ b/nano/qt_test/qt.cpp @@ -481,7 +481,7 @@ TEST (history, short_text) nano::ledger ledger (store, system.nodes[0]->stats); { auto transaction (store.tx_begin_write ()); - store.initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store.initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); 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/secure/blockstore.hpp b/nano/secure/blockstore.hpp index db3389ac69..f797d0242e 100644 --- a/nano/secure/blockstore.hpp +++ b/nano/secure/blockstore.hpp @@ -574,7 +574,7 @@ class block_store { public: virtual ~block_store () = default; - virtual void initialize (nano::write_transaction const &, nano::genesis const &, nano::rep_weights &, std::atomic &) = 0; + virtual void initialize (nano::write_transaction const &, nano::genesis const &, nano::rep_weights &, std::atomic &, std::atomic &) = 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; diff --git a/nano/secure/blockstore_partial.hpp b/nano/secure/blockstore_partial.hpp index b189b16c99..25a9f20cda 100644 --- a/nano/secure/blockstore_partial.hpp +++ b/nano/secure/blockstore_partial.hpp @@ -24,13 +24,14 @@ class block_store_partial : public block_store * If using a different store version than the latest then you may need * to modify some of the objects in the store to be appropriate for the version before an upgrade. */ - void initialize (nano::write_transaction const & transaction_a, nano::genesis const & genesis_a, nano::rep_weights & rep_weights, std::atomic & cemented_count) override + void initialize (nano::write_transaction const & transaction_a, nano::genesis const & genesis_a, nano::rep_weights & rep_weights, std::atomic & cemented_count, std::atomic & block_count_cache) override { auto hash_l (genesis_a.hash ()); assert (latest_v0_begin (transaction_a) == latest_v0_end ()); assert (latest_v1_begin (transaction_a) == latest_v1_end ()); nano::block_sideband sideband (nano::block_type::open, network_params.ledger.genesis_account, 0, network_params.ledger.genesis_amount, 1, nano::seconds_since_epoch ()); block_put (transaction_a, hash_l, *genesis_a.open, sideband); + ++block_count_cache; confirmation_height_put (transaction_a, network_params.ledger.genesis_account, 1); ++cemented_count; account_put (transaction_a, network_params.ledger.genesis_account, { hash_l, network_params.ledger.genesis_account, genesis_a.open->hash (), std::numeric_limits::max (), nano::seconds_since_epoch (), 1, nano::epoch::epoch_0 }); diff --git a/nano/secure/ledger.cpp b/nano/secure/ledger.cpp index d72730d439..18fd1f3606 100644 --- a/nano/secure/ledger.cpp +++ b/nano/secure/ledger.cpp @@ -755,6 +755,10 @@ nano::process_return nano::ledger::process (nano::write_transaction const & tran assert (!nano::work_validate (block_a)); ledger_processor processor (*this, transaction_a, verification); block_a.visit (processor); + if (processor.result.code == nano::process_result::progress) + { + ++block_count_cache; + } return processor.result; } @@ -854,12 +858,11 @@ nano::block_hash nano::ledger::block_source (nano::transaction const & transacti } // Vote weight of an account -nano::uint128_t nano::ledger::weight (nano::transaction const & transaction_a, nano::account const & account_a) +nano::uint128_t nano::ledger::weight (nano::account const & account_a) { if (check_bootstrap_weights.load ()) { - auto blocks = store.block_count (transaction_a); - if (blocks.sum () < bootstrap_weight_max_blocks) + if (block_count_cache < bootstrap_weight_max_blocks) { auto weight = bootstrap_weights.find (account_a); if (weight != bootstrap_weights.end ()) @@ -898,6 +901,10 @@ bool nano::ledger::rollback (nano::write_transaction const & transaction_a, nano list_a.push_back (block); block->visit (rollback); error = rollback.error; + if (!error) + { + --block_count_cache; + } } else { @@ -1126,13 +1133,6 @@ bool nano::ledger::block_not_confirmed_or_not_exists (nano::block const & block_ return result; } -size_t nano::ledger::block_count () const -{ - auto transaction (store.tx_begin_read ()); - auto result (store.block_count (transaction).sum ()); - return result; -} - namespace nano { std::unique_ptr collect_seq_con_info (ledger & ledger, const std::string & name) diff --git a/nano/secure/ledger.hpp b/nano/secure/ledger.hpp index 26bf48ac9e..1b000b6d06 100644 --- a/nano/secure/ledger.hpp +++ b/nano/secure/ledger.hpp @@ -25,7 +25,7 @@ class ledger final nano::uint128_t balance (nano::transaction const &, nano::block_hash const &) const; nano::uint128_t account_balance (nano::transaction const &, nano::account const &); nano::uint128_t account_pending (nano::transaction const &, nano::account const &); - nano::uint128_t weight (nano::transaction const &, nano::account const &); + nano::uint128_t weight (nano::account const &); std::shared_ptr successor (nano::transaction const &, nano::qualified_root const &); std::shared_ptr forked_block (nano::transaction const &, nano::block const &); bool block_confirmed (nano::transaction const & transaction_a, nano::block_hash const & hash_a) const; @@ -55,6 +55,7 @@ class ledger final nano::network_params network_params; nano::block_store & store; std::atomic cemented_count{ 0 }; + std::atomic block_count_cache{ 0 }; nano::rep_weights rep_weights; nano::stat & stats; std::unordered_map bootstrap_weights; diff --git a/nano/slow_test/node.cpp b/nano/slow_test/node.cpp index d4d3fe1007..b8f8cc7412 100644 --- a/nano/slow_test/node.cpp +++ b/nano/slow_test/node.cpp @@ -95,7 +95,7 @@ TEST (ledger, deep_account_compute) nano::ledger ledger (*store, stats); nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count); + store->initialize (transaction, genesis, ledger.rep_weights, ledger.cemented_count, ledger.block_count_cache); nano::work_pool pool (std::numeric_limits::max ()); nano::keypair key; auto balance (nano::genesis_amount - 1); @@ -426,9 +426,8 @@ TEST (wallets, rep_scan) wallet->deterministic_insert (transaction); } } - auto transaction (node.store.tx_begin_read ()); auto begin (std::chrono::steady_clock::now ()); - node.wallets.foreach_representative (transaction, [](nano::public_key const & pub_a, nano::raw_key const & prv_a) { + node.wallets.foreach_representative ([](nano::public_key const & pub_a, nano::raw_key const & prv_a) { }); ASSERT_LT (std::chrono::steady_clock::now () - begin, std::chrono::milliseconds (5)); }