Minecon724/dncurrency
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages 1 Wiki Activity Actions 1

Reduce coupling to store.block.get by using ledger::block interface.

Browse source
This commit is contained in:
Colin LeMahieu 2024-03-05 14:02:33 +00:00
commit 665296acfa
No known key found for this signature in database
GPG key ID: 43708520C8DFB938
20 changed files with 162 additions and 157 deletions
Download patch file Download diff file Expand all files Collapse all files

24
nano/core_test/block_store.cpp
View file

@ -1126,29 +1126,29 @@ TEST (mdb_block_store, sideband_height)
.work (*pool.generate (key3.pub))
.build ();
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, open));
auto block1 (store.block.get (transaction, nano::dev::genesis->hash ()));
auto block1 = ledger.block (transaction, nano::dev::genesis->hash ());
ASSERT_EQ (block1->sideband ().height, 1);
auto block2 (store.block.get (transaction, send->hash ()));
auto block2 = ledger.block (transaction, send->hash ());
ASSERT_EQ (block2->sideband ().height, 2);
auto block3 (store.block.get (transaction, receive->hash ()));
auto block3 = ledger.block (transaction, receive->hash ());
ASSERT_EQ (block3->sideband ().height, 3);
auto block4 (store.block.get (transaction, change->hash ()));
auto block4 = ledger.block (transaction, change->hash ());
ASSERT_EQ (block4->sideband ().height, 4);
auto block5 (store.block.get (transaction, state_send1->hash ()));
auto block5 = ledger.block (transaction, state_send1->hash ());
ASSERT_EQ (block5->sideband ().height, 5);
auto block6 (store.block.get (transaction, state_send2->hash ()));
auto block6 = ledger.block (transaction, state_send2->hash ());
ASSERT_EQ (block6->sideband ().height, 6);
auto block7 (store.block.get (transaction, state_send3->hash ()));
auto block7 = ledger.block (transaction, state_send3->hash ());
ASSERT_EQ (block7->sideband ().height, 7);
auto block8 (store.block.get (transaction, state_open->hash ()));
auto block8 = ledger.block (transaction, state_open->hash ());
ASSERT_EQ (block8->sideband ().height, 1);
auto block9 (store.block.get (transaction, epoch->hash ()));
auto block9 = ledger.block (transaction, epoch->hash ());
ASSERT_EQ (block9->sideband ().height, 2);
auto block10 (store.block.get (transaction, epoch_open->hash ()));
auto block10 = ledger.block (transaction, epoch_open->hash ());
ASSERT_EQ (block10->sideband ().height, 1);
auto block11 (store.block.get (transaction, state_receive->hash ()));
auto block11 = ledger.block (transaction, state_receive->hash ());
ASSERT_EQ (block11->sideband ().height, 2);
auto block12 (store.block.get (transaction, open->hash ()));
auto block12 = ledger.block (transaction, open->hash ());
ASSERT_EQ (block12->sideband ().height, 1);
}

38
nano/core_test/ledger.cpp
View file

@ -78,7 +78,7 @@ TEST (ledger, process_modifies_sideband)
.work (*pool.generate (nano::dev::genesis->hash ()))
.build ();
ASSERT_EQ (nano::block_status::progress, ledger.process (store.tx_begin_write (), send1));
ASSERT_EQ (send1->sideband ().timestamp, store.block.get (store.tx_begin_read (), send1->hash ())->sideband ().timestamp);
ASSERT_EQ (send1->sideband ().timestamp, ledger.block (store.tx_begin_read (), send1->hash ())->sideband ().timestamp);
}
// Create a send block and publish it.
@ -118,7 +118,7 @@ TEST (ledger, process_send)
auto info2 = ledger.account_info (transaction, nano::dev::genesis_key.pub);
ASSERT_TRUE (info2);
ASSERT_EQ (2, info2->block_count);
auto latest6 = store.block.get (transaction, info2->head);
auto latest6 = ledger.block (transaction, info2->head);
ASSERT_NE (nullptr, latest6);
auto latest7 = dynamic_cast<nano::send_block *> (latest6.get ());
ASSERT_NE (nullptr, latest7);
@ -150,14 +150,14 @@ TEST (ledger, process_send)
ASSERT_EQ (nano::dev::constants.genesis_amount - 50, ledger.weight (key2.pub));
auto info3 = ledger.account_info (transaction, nano::dev::genesis_key.pub);
ASSERT_TRUE (info3);
auto latest2 = store.block.get (transaction, info3->head);
auto latest2 = ledger.block (transaction, info3->head);
ASSERT_NE (nullptr, latest2);
auto latest3 = dynamic_cast<nano::send_block *> (latest2.get ());
ASSERT_NE (nullptr, latest3);
ASSERT_EQ (*send, *latest3);
auto info4 = ledger.account_info (transaction, key2.pub);
ASSERT_TRUE (info4);
auto latest4 = store.block.get (transaction, info4->head);
auto latest4 = ledger.block (transaction, info4->head);
ASSERT_NE (nullptr, latest4);
auto latest5 = dynamic_cast<nano::open_block *> (latest4.get ());
ASSERT_NE (nullptr, latest5);
@ -2383,7 +2383,7 @@ TEST (ledger, state_send_receive)
.build ();
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1));
ASSERT_TRUE (store.block.exists (transaction, send1->hash ()));
auto send2 = store.block.get (transaction, send1->hash ());
auto send2 = ledger.block (transaction, send1->hash ());
ASSERT_NE (nullptr, send2);
ASSERT_EQ (*send1, *send2);
ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.balance (transaction, send1->hash ()));
@ -2406,7 +2406,7 @@ TEST (ledger, state_send_receive)
.build ();
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive1));
ASSERT_TRUE (store.block.exists (transaction, receive1->hash ()));
auto receive2 = store.block.get (transaction, receive1->hash ());
auto receive2 = ledger.block (transaction, receive1->hash ());
ASSERT_NE (nullptr, receive2);
ASSERT_EQ (*receive1, *receive2);
ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.balance (transaction, receive1->hash ()));
@ -2438,7 +2438,7 @@ TEST (ledger, state_receive)
.build ();
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1));
ASSERT_TRUE (store.block.exists (transaction, send1->hash ()));
auto send2 = store.block.get (transaction, send1->hash ());
auto send2 = ledger.block (transaction, send1->hash ());
ASSERT_NE (nullptr, send2);
ASSERT_EQ (*send1, *send2);
ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.balance (transaction, send1->hash ()));
@ -2456,7 +2456,7 @@ TEST (ledger, state_receive)
.build ();
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive1));
ASSERT_TRUE (store.block.exists (transaction, receive1->hash ()));
auto receive2 = store.block.get (transaction, receive1->hash ());
auto receive2 = ledger.block (transaction, receive1->hash ());
ASSERT_NE (nullptr, receive2);
ASSERT_EQ (*receive1, *receive2);
ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.balance (transaction, receive1->hash ()));
@ -2489,7 +2489,7 @@ TEST (ledger, state_rep_change)
.build ();
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, change1));
ASSERT_TRUE (store.block.exists (transaction, change1->hash ()));
auto change2 = store.block.get (transaction, change1->hash ());
auto change2 = ledger.block (transaction, change1->hash ());
ASSERT_NE (nullptr, change2);
ASSERT_EQ (*change1, *change2);
ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.balance (transaction, change1->hash ()));
@ -2523,7 +2523,7 @@ TEST (ledger, state_open)
.build ();
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1));
ASSERT_TRUE (store.block.exists (transaction, send1->hash ()));
auto send2 = store.block.get (transaction, send1->hash ());
auto send2 = ledger.block (transaction, send1->hash ());
ASSERT_NE (nullptr, send2);
ASSERT_EQ (*send1, *send2);
ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.balance (transaction, send1->hash ()));
@ -2543,7 +2543,7 @@ TEST (ledger, state_open)
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, open1));
ASSERT_FALSE (store.pending.exists (transaction, nano::pending_key (destination.pub, send1->hash ())));
ASSERT_TRUE (store.block.exists (transaction, open1->hash ()));
auto open2 = store.block.get (transaction, open1->hash ());
auto open2 = ledger.block (transaction, open1->hash ());
ASSERT_NE (nullptr, open2);
ASSERT_EQ (*open1, *open2);
ASSERT_EQ (nano::Gxrb_ratio, ledger.balance (transaction, open1->hash ()));
@ -2666,7 +2666,7 @@ TEST (ledger, state_unreceivable_fail)
.build ();
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1));
ASSERT_TRUE (store.block.exists (transaction, send1->hash ()));
auto send2 = store.block.get (transaction, send1->hash ());
auto send2 = ledger.block (transaction, send1->hash ());
ASSERT_NE (nullptr, send2);
ASSERT_EQ (*send1, *send2);
ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.balance (transaction, send1->hash ()));
@ -2703,7 +2703,7 @@ TEST (ledger, state_receive_bad_amount_fail)
.build ();
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1));
ASSERT_TRUE (store.block.exists (transaction, send1->hash ()));
auto send2 = store.block.get (transaction, send1->hash ());
auto send2 = ledger.block (transaction, send1->hash ());
ASSERT_NE (nullptr, send2);
ASSERT_EQ (*send1, *send2);
ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.balance (transaction, send1->hash ()));
@ -2775,7 +2775,7 @@ TEST (ledger, state_receive_wrong_account_fail)
.build ();
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1));
ASSERT_TRUE (store.block.exists (transaction, send1->hash ()));
auto send2 = store.block.get (transaction, send1->hash ());
auto send2 = ledger.block (transaction, send1->hash ());
ASSERT_NE (nullptr, send2);
ASSERT_EQ (*send1, *send2);
ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.balance (transaction, send1->hash ()));
@ -2969,7 +2969,7 @@ TEST (ledger, state_send_change)
.build ();
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1));
ASSERT_TRUE (store.block.exists (transaction, send1->hash ()));
auto send2 = store.block.get (transaction, send1->hash ());
auto send2 = ledger.block (transaction, send1->hash ());
ASSERT_NE (nullptr, send2);
ASSERT_EQ (*send1, *send2);
ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.balance (transaction, send1->hash ()));
@ -3002,7 +3002,7 @@ TEST (ledger, state_receive_change)
.build ();
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1));
ASSERT_TRUE (store.block.exists (transaction, send1->hash ()));
auto send2 = store.block.get (transaction, send1->hash ());
auto send2 = ledger.block (transaction, send1->hash ());
ASSERT_NE (nullptr, send2);
ASSERT_EQ (*send1, *send2);
ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.balance (transaction, send1->hash ()));
@ -3021,7 +3021,7 @@ TEST (ledger, state_receive_change)
.build ();
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive1));
ASSERT_TRUE (store.block.exists (transaction, receive1->hash ()));
auto receive2 = store.block.get (transaction, receive1->hash ());
auto receive2 = ledger.block (transaction, receive1->hash ());
ASSERT_NE (nullptr, receive2);
ASSERT_EQ (*receive1, *receive2);
ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.balance (transaction, receive1->hash ()));
@ -3141,7 +3141,7 @@ TEST (ledger, state_rollback_send)
.build ();
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1));
ASSERT_TRUE (store.block.exists (transaction, send1->hash ()));
auto send2 = store.block.get (transaction, send1->hash ());
auto send2 = ledger.block (transaction, send1->hash ());
ASSERT_NE (nullptr, send2);
ASSERT_EQ (*send1, *send2);
ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.account_balance (transaction, nano::dev::genesis->account ()));
@ -4291,7 +4291,7 @@ TEST (ledger, unchecked_epoch_invalid)
auto info = node1.ledger.account_info (transaction, destination.pub);
ASSERT_TRUE (info);
ASSERT_NE (info->epoch (), nano::epoch::epoch_1);
auto epoch2_store = node1.store.block.get (transaction, epoch2->hash ());
auto epoch2_store = node1.ledger.block (transaction, epoch2->hash ());
ASSERT_NE (nullptr, epoch2_store);
ASSERT_EQ (nano::epoch::epoch_0, epoch2_store->sideband ().details.epoch);
ASSERT_TRUE (epoch2_store->sideband ().details.is_send);

4
nano/core_test/wallet.cpp
View file

@ -181,7 +181,7 @@ TEST (wallet, spend_all_one)
auto transaction (node1.store.tx_begin_read ());
auto info2 = node1.ledger.account_info (transaction, nano::dev::genesis_key.pub);
ASSERT_NE (latest1, info2->head);
auto block (node1.store.block.get (transaction, info2->head));
auto block = node1.ledger.block (transaction, info2->head);
ASSERT_NE (nullptr, block);
ASSERT_EQ (latest1, block->previous ());
ASSERT_TRUE (info2->balance.is_zero ());
@ -216,7 +216,7 @@ TEST (wallet, spend)
auto info2 = node1.ledger.account_info (transaction, nano::dev::genesis_key.pub);
ASSERT_TRUE (info2);
ASSERT_NE (latest1, info2->head);
auto block (node1.store.block.get (transaction, info2->head));
auto block = node1.ledger.block (transaction, info2->head);
ASSERT_NE (nullptr, block);
ASSERT_EQ (latest1, block->previous ());
ASSERT_TRUE (info2->balance.is_zero ());

14
nano/nano_node/entry.cpp
View file

@ -1411,17 +1411,17 @@ int main (int argc, char * const * argv)
auto hash (info.open_block);
nano::block_hash calculated_hash (0);
auto block (node->store.block.get (transaction, hash)); // Block data
auto block = node->ledger.block (transaction, hash); // Block data
uint64_t height (0);
if (node->ledger.pruning && confirmation_height_info.height != 0)
{
hash = confirmation_height_info.frontier;
block = node->store.block.get (transaction, hash);
block = node->ledger.block (transaction, hash);
// Iteration until pruned block
bool pruned_block (false);
while (!pruned_block && !block->previous ().is_zero ())
{
auto previous_block (node->store.block.get (transaction, block->previous ()));
auto previous_block = node->ledger.block (transaction, block->previous ());
if (previous_block != nullptr)
{
hash = previous_block->hash ();
@ -1591,7 +1591,7 @@ int main (int argc, char * const * argv)
// Retrieving block data
if (!hash.is_zero ())
{
block = node->store.block.get (transaction, hash);
block = node->ledger.block (transaction, hash);
}
}
// Check if required block exists
@ -1676,7 +1676,7 @@ int main (int argc, char * const * argv)
std::cout << boost::str (boost::format ("%1% pending blocks validated\n") % count);
}
// Check block existance
auto block (node->store.block.get (transaction, key.hash));
auto block = node->ledger.block (transaction, key.hash);
bool pruned (false);
if (block == nullptr)
{
@ -1693,7 +1693,7 @@ int main (int argc, char * const * argv)
bool previous_pruned = node->ledger.pruning && node->store.pruned.exists (transaction, block->previous ());
if (previous_pruned)
{
block = node->store.block.get (transaction, key.hash);
block = node->ledger.block (transaction, key.hash);
}
if (auto state = dynamic_cast<nano::state_block *> (block.get ()))
{
@ -1800,7 +1800,7 @@ int main (int argc, char * const * argv)
while (!hash.is_zero ())
{
// Retrieving block data
auto block (source_node->store.block.get (transaction, hash));
auto block = source_node->ledger.block (transaction, hash);
if (block != nullptr)
{
++count;

6
nano/node/bootstrap/bootstrap_server.cpp
View file

@ -253,13 +253,13 @@ std::vector<std::shared_ptr<nano::block>> nano::bootstrap_server::prepare_blocks
std::vector<std::shared_ptr<nano::block>> result;
if (!start_block.is_zero ())
{
std::shared_ptr<nano::block> current = store.block.get (transaction, start_block);
std::shared_ptr<nano::block> current = ledger.block (transaction, start_block);
while (current && result.size () < count)
{
result.push_back (current);
auto successor = current->sideband ().successor;
current = store.block.get (transaction, successor);
current = ledger.block (transaction, successor);
}
}
return result;
@ -337,4 +337,4 @@ nano::asc_pull_ack nano::bootstrap_server::process (const store::transaction & t
response.payload = response_payload;
response.update_header ();
return response;
}
}

14
nano/node/confirmation_height_bounded.cpp
View file

@ -83,7 +83,7 @@ void nano::confirmation_height_bounded::process (std::shared_ptr<nano::block> or
}
else
{
block = ledger.store.block.get (transaction, current);
block = ledger.block (transaction, current);
}
if (!block)
@ -227,7 +227,7 @@ nano::block_hash nano::confirmation_height_bounded::get_least_unconfirmed_hash_f
{
if (block_height_a > confirmation_height_info_a.height)
{
auto block (ledger.store.block.get (transaction_a, confirmation_height_info_a.frontier));
auto block = ledger.block (transaction_a, confirmation_height_info_a.frontier);
release_assert (block != nullptr);
least_unconfirmed_hash = block->sideband ().successor;
block_height_a = block->sideband ().height + 1;
@ -255,7 +255,7 @@ bool nano::confirmation_height_bounded::iterate (store::read_transaction const &
// Keep iterating upwards until we either reach the desired block or the second receive.
// Once a receive is cemented, we can cement all blocks above it until the next receive, so store those details for later.
++num_blocks;
auto block = ledger.store.block.get (transaction_a, hash);
auto block = ledger.block (transaction_a, hash);
auto source (block->source ());
if (source.is_zero ())
{
@ -384,7 +384,7 @@ void nano::confirmation_height_bounded::cement_blocks (nano::write_guard & scope
// Extra debug checks
nano::confirmation_height_info confirmation_height_info;
ledger.store.confirmation_height.get (transaction, account, confirmation_height_info);
auto block (ledger.store.block.get (transaction, confirmed_frontier));
auto block = ledger.block (transaction, confirmed_frontier);
debug_assert (block != nullptr);
debug_assert (block->sideband ().height == confirmation_height_info.height + num_blocks_cemented);
#endif
@ -414,14 +414,14 @@ void nano::confirmation_height_bounded::cement_blocks (nano::write_guard & scope
}
else
{
auto block = ledger.store.block.get (transaction, confirmation_height_info.frontier);
auto block = ledger.block (transaction, confirmation_height_info.frontier);
new_cemented_frontier = block->sideband ().successor;
num_blocks_confirmed = pending.top_height - confirmation_height_info.height;
start_height = confirmation_height_info.height + 1;
}
auto total_blocks_cemented = 0;
auto block = ledger.store.block.get (transaction, new_cemented_frontier);
auto block = ledger.block (transaction, new_cemented_frontier);
// Cementing starts from the bottom of the chain and works upwards. This is because chains can have effectively
// an infinite number of send/change blocks in a row. We don't want to hold the write transaction open for too long.
@ -480,7 +480,7 @@ void nano::confirmation_height_bounded::cement_blocks (nano::write_guard & scope
if (!last_iteration)
{
new_cemented_frontier = block->sideband ().successor;
block = ledger.store.block.get (transaction, new_cemented_frontier);
block = ledger.block (transaction, new_cemented_frontier);
}
else
{

4
nano/node/confirmation_height_unbounded.cpp
View file

@ -376,7 +376,7 @@ void nano::confirmation_height_unbounded::cement_blocks (nano::write_guard & sco
auto confirmation_height = confirmation_height_info.height;
if (pending.height > confirmation_height)
{
auto block = ledger.store.block.get (transaction, pending.hash);
auto block = ledger.block (transaction, pending.hash);
debug_assert (ledger.pruning || block != nullptr);
debug_assert (ledger.pruning || block->sideband ().height == pending.height);
@ -438,7 +438,7 @@ std::shared_ptr<nano::block> nano::confirmation_height_unbounded::get_block_and_
}
else
{
auto block (ledger.store.block.get (transaction_a, hash_a));
auto block = ledger.block (transaction_a, hash_a);
block_cache.emplace (hash_a, block);
return block;
}

52
nano/node/json_handler.cpp
View file

@ -397,7 +397,7 @@ uint64_t nano::json_handler::difficulty_ledger (nano::block const & block_a)
auto previous (block_a.previous ());
if (!previous.is_zero ())
{
block_previous = node.store.block.get (transaction, previous);
block_previous = node.ledger.block (transaction, previous);
}
// Send check
if (block_previous != nullptr)
@ -413,7 +413,7 @@ uint64_t nano::json_handler::difficulty_ledger (nano::block const & block_a)
auto link (block_a.link ());
if (!link.is_zero () && !details.is_send)
{
auto block_link (node.store.block.get (transaction, link.as_block_hash ()));
auto block_link = node.ledger.block (transaction, link.as_block_hash ());
if (block_link != nullptr && node.store.pending.exists (transaction, nano::pending_key (block_a.account (), link.as_block_hash ())))
{
details.epoch = std::max (details.epoch, block_link->sideband ().details.epoch);
@ -672,7 +672,7 @@ void nano::json_handler::account_info ()
std::shared_ptr<nano::block> confirmed_frontier_block;
if (include_confirmed && confirmation_height_info.height > 0)
{
confirmed_frontier_block = node.store.block.get (transaction, confirmation_height_info.frontier);
confirmed_frontier_block = node.ledger.block (transaction, confirmation_height_info.frontier);
}
if (representative)
@ -686,7 +686,7 @@ void nano::json_handler::account_info ()
confirmed_representative = confirmed_frontier_block->representative ();
if (confirmed_representative.is_zero ())
{
confirmed_representative = node.store.block.get (transaction, node.ledger.representative (transaction, confirmation_height_info.frontier))->representative ();
confirmed_representative = node.ledger.block (transaction, node.ledger.representative (transaction, confirmation_height_info.frontier))->representative ();
}
}
@ -1145,7 +1145,7 @@ void nano::json_handler::block_info ()
if (!ec)
{
auto transaction (node.store.tx_begin_read ());
auto block (node.store.block.get (transaction, hash));
auto block = node.ledger.block (transaction, hash);
if (block != nullptr)
{
nano::account account (block->account ().is_zero () ? block->sideband ().account : block->account ());
@ -1197,7 +1197,7 @@ void nano::json_handler::block_confirm ()
if (!ec)
{
auto transaction (node.store.tx_begin_read ());
auto block_l (node.store.block.get (transaction, hash));
auto block_l = node.ledger.block (transaction, hash);
if (block_l != nullptr)
{
if (!node.ledger.block_confirmed (transaction, hash))
@ -1252,7 +1252,7 @@ void nano::json_handler::blocks ()
nano::block_hash hash;
if (!hash.decode_hex (hash_text))
{
auto block (node.store.block.get (transaction, hash));
auto block = node.ledger.block (transaction, hash);
if (block != nullptr)
{
if (json_block_l)
@ -1303,7 +1303,7 @@ void nano::json_handler::blocks_info ()
nano::block_hash hash;
if (!hash.decode_hex (hash_text))
{
auto block (node.store.block.get (transaction, hash));
auto block = node.ledger.block (transaction, hash);
if (block != nullptr)
{
boost::property_tree::ptree entry;
@ -1385,7 +1385,7 @@ void nano::json_handler::blocks_info ()
if (source)
{
nano::block_hash source_hash (node.ledger.block_source (transaction, *block));
auto block_a (node.store.block.get (transaction, source_hash));
auto block_a = node.ledger.block (transaction, source_hash);
if (block_a != nullptr)
{
auto source_account (node.ledger.account (transaction, source_hash));
@ -1945,7 +1945,7 @@ void nano::json_handler::chain (bool successors)
auto transaction (node.store.tx_begin_read ());
while (!hash.is_zero () && blocks.size () < count)
{
auto block_l (node.store.block.get (transaction, hash));
auto block_l = node.ledger.block (transaction, hash);
if (block_l != nullptr)
{
if (offset > 0)
@ -2643,7 +2643,7 @@ void nano::json_handler::account_history ()
boost::property_tree::ptree history;
bool output_raw (request.get_optional<bool> ("raw") == true);
response_l.put ("account", account.to_account ());
auto block (node.store.block.get (transaction, hash));
auto block = node.ledger.block (transaction, hash);
while (block != nullptr && count > 0)
{
if (offset > 0)
@ -2671,7 +2671,7 @@ void nano::json_handler::account_history ()
}
}
hash = reverse ? node.store.block.successor (transaction, hash) : block->previous ();
block = node.store.block.get (transaction, hash);
block = node.ledger.block (transaction, hash);
}
response_l.add_child ("history", history);
if (!hash.is_zero ())
@ -3164,7 +3164,7 @@ void nano::json_handler::receivable_exists ()
if (!ec)
{
auto transaction (node.store.tx_begin_read ());
auto block (node.store.block.get (transaction, hash));
auto block = node.ledger.block (transaction, hash);
if (block != nullptr)
{
auto exists (false);
@ -3638,28 +3638,28 @@ void nano::json_handler::republish ()
{
boost::property_tree::ptree blocks;
auto transaction (node.store.tx_begin_read ());
auto block (node.store.block.get (transaction, hash));
auto block = node.ledger.block (transaction, hash);
if (block != nullptr)
{
std::deque<std::shared_ptr<nano::block>> republish_bundle;
for (auto i (0); !hash.is_zero () && i < count; ++i)
{
block = node.store.block.get (transaction, hash);
block = node.ledger.block (transaction, hash);
if (sources != 0) // Republish source chain
{
nano::block_hash source (node.ledger.block_source (transaction, *block));
auto block_a (node.store.block.get (transaction, source));
auto block_a = node.ledger.block (transaction, source);
std::vector<nano::block_hash> hashes;
while (block_a != nullptr && hashes.size () < sources)
{
hashes.push_back (source);
source = block_a->previous ();
block_a = node.store.block.get (transaction, source);
block_a = node.ledger.block (transaction, source);
}
std::reverse (hashes.begin (), hashes.end ());
for (auto & hash_l : hashes)
{
block_a = node.store.block.get (transaction, hash_l);
block_a = node.ledger.block (transaction, hash_l);
republish_bundle.push_back (std::move (block_a));
boost::property_tree::ptree entry_l;
entry_l.put ("", hash_l.to_string ());
@ -3672,14 +3672,14 @@ void nano::json_handler::republish ()
blocks.push_back (std::make_pair ("", entry));
if (destinations != 0) // Republish destination chain
{
auto block_b (node.store.block.get (transaction, hash));
auto block_b = node.ledger.block (transaction, hash);
auto destination (node.ledger.block_destination (transaction, *block_b));
if (!destination.is_zero ())
{
if (!node.store.pending.exists (transaction, nano::pending_key (destination, hash)))
{
nano::block_hash previous (node.ledger.latest (transaction, destination));
auto block_d (node.store.block.get (transaction, previous));
auto block_d = node.ledger.block (transaction, previous);
nano::block_hash source;
std::vector<nano::block_hash> hashes;
while (block_d != nullptr && hash != source)
@ -3687,7 +3687,7 @@ void nano::json_handler::republish ()
hashes.push_back (previous);
source = node.ledger.block_source (transaction, *block_d);
previous = block_d->previous ();
block_d = node.store.block.get (transaction, previous);
block_d = node.ledger.block (transaction, previous);
}
std::reverse (hashes.begin (), hashes.end ());
if (hashes.size () > destinations)
@ -3696,7 +3696,7 @@ void nano::json_handler::republish ()
}
for (auto & hash_l : hashes)
{
block_d = node.store.block.get (transaction, hash_l);
block_d = node.ledger.block (transaction, hash_l);
republish_bundle.push_back (std::move (block_d));
boost::property_tree::ptree entry_l;
entry_l.put ("", hash_l.to_string ());
@ -4658,7 +4658,7 @@ void nano::json_handler::wallet_history ()
auto hash (info->head);
while (timestamp >= modified_since && !hash.is_zero ())
{
auto block (node.store.block.get (block_transaction, hash));
auto block = node.ledger.block (block_transaction, hash);
timestamp = block->sideband ().timestamp;
if (block != nullptr && timestamp >= modified_since)
{
@ -4932,7 +4932,7 @@ void nano::json_handler::wallet_republish ()
while (!latest.is_zero () && hashes.size () < count)
{
hashes.push_back (latest);
block = node.store.block.get (block_transaction, latest);
block = node.ledger.block (block_transaction, latest);
if (block != nullptr)
{
latest = block->previous ();
@ -4945,7 +4945,7 @@ void nano::json_handler::wallet_republish ()
std::reverse (hashes.begin (), hashes.end ());
for (auto & hash : hashes)
{
block = node.store.block.get (block_transaction, hash);
block = node.ledger.block (block_transaction, hash);
republish_bundle.push_back (std::move (block));
boost::property_tree::ptree entry;
entry.put ("", hash.to_string ());
@ -5463,7 +5463,7 @@ bool block_confirmed (nano::node & node, nano::store::transaction & transaction,
// This just checks it's not currently undergoing an active transaction
else if (!include_only_confirmed)
{
auto block (node.store.block.get (transaction, hash));
auto block = node.ledger.block (transaction, hash);
is_confirmed = (block != nullptr && !node.active.active (*block));
}

7
nano/node/node.cpp
View file

@ -727,8 +727,7 @@ nano::uint128_t nano::node::balance (nano::account const & account_a)
std::shared_ptr<nano::block> nano::node::block (nano::block_hash const & hash_a)
{
auto const transaction (store.tx_begin_read ());
return store.block.get (transaction, hash_a);
return ledger.block (store.tx_begin_read (), hash_a);
}
std::pair<nano::uint128_t, nano::uint128_t> nano::node::balance_pending (nano::account const & account_a, bool only_confirmed_a)
@ -921,7 +920,7 @@ bool nano::node::collect_ledger_pruning_targets (std::deque<nano::block_hash> &
uint64_t depth (0);
while (!hash.is_zero () && depth < max_depth_a)
{
auto block (store.block.get (transaction, hash));
auto block = ledger.block (transaction, hash);
if (block != nullptr)
{
if (block->sideband ().timestamp > cutoff_time_a || depth == 0)
@ -1271,7 +1270,7 @@ void nano::node::process_confirmed (nano::election_status const & status_a, uint
{
auto hash (status_a.winner->hash ());
decltype (iteration_a) const num_iters = (config.block_processor_batch_max_time / network_params.node.process_confirmed_interval) * 4;
if (auto block_l = ledger.store.block.get (ledger.store.tx_begin_read (), hash))
if (auto block_l = ledger.block (ledger.store.tx_begin_read (), hash))
{
logger.trace (nano::log::type::node, nano::log::detail::process_confirmed, nano::log::arg{ "block", block_l });

8
nano/node/request_aggregator.cpp
View file

@ -204,12 +204,12 @@ std::pair<std::vector<std::shared_ptr<nano::block>>, std::vector<std::shared_ptr
if (!final_vote_hashes.empty ())
{
generate_final_vote = true;
block = ledger.store.block.get (transaction, final_vote_hashes[0]);
block = ledger.block (transaction, final_vote_hashes[0]);
// Allow same root vote
if (block != nullptr && final_vote_hashes.size () > 1)
{
to_generate_final.push_back (block);
block = ledger.store.block.get (transaction, final_vote_hashes[1]);
block = ledger.block (transaction, final_vote_hashes[1]);
debug_assert (final_vote_hashes.size () == 2);
}
}
@ -223,7 +223,7 @@ std::pair<std::vector<std::shared_ptr<nano::block>>, std::vector<std::shared_ptr
// 4. Ledger by hash
if (block == nullptr)
{
block = ledger.store.block.get (transaction, hash);
block = ledger.block (transaction, hash);
// Confirmation status. Generate final votes for confirmed
if (block != nullptr)
{
@ -250,7 +250,7 @@ std::pair<std::vector<std::shared_ptr<nano::block>>, std::vector<std::shared_ptr
}
if (!successor.is_zero ())
{
auto successor_block = ledger.store.block.get (transaction, successor);
auto successor_block = ledger.block (transaction, successor);
debug_assert (successor_block != nullptr);
block = std::move (successor_block);
// 5. Votes in cache for successor

4
nano/node/scheduler/hinted.cpp
View file

@ -76,7 +76,7 @@ void nano::scheduler::hinted::activate (const nano::store::read_transaction & tr
stack.pop ();
// Check if block exists
if (auto block = node.store.block.get (transaction, current_hash); block)
if (auto block = node.ledger.block (transaction, current_hash); block)
{
// Ensure block is not already confirmed
if (node.block_confirmed_or_being_confirmed (transaction, current_hash))
@ -283,4 +283,4 @@ nano::error nano::scheduler::hinted_config::deserialize (nano::tomlconfig & toml
}
return toml.get_error ();
}
}

2
nano/node/scheduler/priority.cpp
View file

@ -47,7 +47,7 @@ bool nano::scheduler::priority::activate (nano::account const & account_a, store
{
debug_assert (conf_info.frontier != info->head);
auto hash = conf_info.height == 0 ? info->open_block : node.store.block.successor (transaction, conf_info.frontier);
auto block = node.store.block.get (transaction, hash);
auto block = node.ledger.block (transaction, hash);
debug_assert (block != nullptr);
if (node.ledger.dependents_confirmed (transaction, *block))
{

2
nano/node/voting.cpp
View file

@ -186,7 +186,7 @@ nano::vote_generator::~vote_generator ()
bool nano::vote_generator::should_vote (store::write_transaction const & transaction, nano::root const & root_a, nano::block_hash const & hash_a)
{
auto block = ledger.store.block.get (transaction, hash_a);
auto block = ledger.block (transaction, hash_a);
bool should_vote = false;
if (is_final)
{

4
nano/node/wallet.cpp
View file

@ -955,7 +955,7 @@ std::shared_ptr<nano::block> nano::wallet::send_action (nano::account const & so
if (status == 0)
{
nano::block_hash hash (result);
block = wallets.node.store.block.get (block_transaction, hash);
block = wallets.node.ledger.block (block_transaction, hash);
if (block != nullptr)
{
cached_block = true;
@ -1199,7 +1199,7 @@ bool nano::wallet::search_receivable (store::transaction const & wallet_transact
}
else if (!wallets.node.confirmation_height_processor.is_processing_block (hash))
{
auto block (wallets.node.store.block.get (block_transaction, hash));
auto block = wallets.node.ledger.block (block_transaction, hash);
if (block)
{
// Request confirmation for block which is not being processed yet

10
nano/qt/qt.cpp
View file

@ -622,7 +622,7 @@ void nano_qt::history::refresh ()
for (auto i (0), n (tx_count->value ()); i < n && !hash.is_zero (); ++i)
{
QList<QStandardItem *> items;
auto block (ledger.store.block.get (transaction, hash));
auto block (ledger.block (transaction, hash));
if (block != nullptr)
{
block->visit (visitor);
@ -671,7 +671,7 @@ nano_qt::block_viewer::block_viewer (nano_qt::wallet & wallet_a) :
if (!hash_l.decode_hex (hash->text ().toStdString ()))
{
auto transaction (this->wallet.node.store.tx_begin_read ());
auto block_l (this->wallet.node.store.block.get (transaction, hash_l));
auto block_l (this->wallet.node.ledger.block (transaction, hash_l));
if (block_l != nullptr)
{
std::string contents;
@ -717,7 +717,7 @@ void nano_qt::block_viewer::rebroadcast_action (nano::block_hash const & hash_a)
{
auto done (true);
auto transaction (wallet.node.ledger.store.tx_begin_read ());
auto block (wallet.node.store.block.get (transaction, hash_a));
auto block (wallet.node.ledger.block (transaction, hash_a));
if (block != nullptr)
{
wallet.node.network.flood_block (block);
@ -2299,7 +2299,7 @@ void nano_qt::block_creation::create_receive ()
{
auto transaction (wallet.node.wallets.tx_begin_read ());
auto block_transaction (wallet.node.store.tx_begin_read ());
auto block_l (wallet.node.store.block.get (block_transaction, source_l));
auto block_l (wallet.node.ledger.block (block_transaction, source_l));
if (block_l != nullptr)
{
auto const & destination (wallet.node.ledger.block_destination (block_transaction, *block_l));
@ -2464,7 +2464,7 @@ void nano_qt::block_creation::create_open ()
{
auto transaction (wallet.node.wallets.tx_begin_read ());
auto block_transaction (wallet.node.store.tx_begin_read ());
auto block_l (wallet.node.store.block.get (block_transaction, source_l));
auto block_l (wallet.node.ledger.block (block_transaction, source_l));
if (block_l != nullptr)
{
auto const & destination (wallet.node.ledger.block_destination (block_transaction, *block_l));

6
nano/rpc_test/rpc.cpp
View file

@ -2395,7 +2395,7 @@ TEST (rpc, account_representative_set)
wallet.insert_adhoc (key2.prv);
auto key2_open_block_hash = wallet.send_sync (nano::dev::genesis_key.pub, key2.pub, node->config.receive_minimum.number ());
ASSERT_TIMELY (5s, node->ledger.block_confirmed (node->store.tx_begin_read (), key2_open_block_hash));
auto key2_open_block = node->store.block.get (node->store.tx_begin_read (), key2_open_block_hash);
auto key2_open_block = node->ledger.block (node->store.tx_begin_read (), key2_open_block_hash);
ASSERT_EQ (nano::dev::genesis_key.pub, key2_open_block->representative ());
// now change the representative of key2 to be genesis
@ -2412,7 +2412,7 @@ TEST (rpc, account_representative_set)
nano::block_hash hash;
ASSERT_FALSE (hash.decode_hex (block_text1));
ASSERT_FALSE (hash.is_zero ());
auto block = node->store.block.get (node->store.tx_begin_read (), hash);
auto block = node->ledger.block (node->store.tx_begin_read (), hash);
ASSERT_NE (block, nullptr);
ASSERT_TIMELY (5s, node->ledger.block_confirmed (node->store.tx_begin_read (), hash));
ASSERT_EQ (key2.pub, block->representative ());
@ -5228,7 +5228,7 @@ TEST (rpc, confirmation_height_currently_processing)
std::shared_ptr<nano::block> frontier;
{
auto transaction = node->store.tx_begin_read ();
frontier = node->store.block.get (transaction, previous_genesis_chain_hash);
frontier = node->ledger.block (transaction, previous_genesis_chain_hash);
}
boost::property_tree::ptree request;

113
nano/secure/ledger.cpp
View file

@ -695,7 +695,7 @@ ledger_processor::ledger_processor (nano::ledger & ledger_a, nano::store::write_
class representative_visitor final : public nano::block_visitor
{
public:
representative_visitor (nano::store::transaction const & transaction_a, nano::store::component & store_a);
representative_visitor (nano::store::transaction const & transaction_a, nano::ledger & ledger);
~representative_visitor () = default;
void compute (nano::block_hash const & hash_a);
void send_block (nano::send_block const & block_a) override;
@ -704,15 +704,15 @@ public:
void change_block (nano::change_block const & block_a) override;
void state_block (nano::state_block const & block_a) override;
nano::store::transaction const & transaction;
nano::store::component & store;
nano::ledger & ledger;
nano::block_hash current;
nano::block_hash result;
};
representative_visitor::representative_visitor (nano::store::transaction const & transaction_a, nano::store::component & store_a) :
transaction (transaction_a),
store (store_a),
result (0)
representative_visitor::representative_visitor (nano::store::transaction const & transaction_a, nano::ledger & ledger) :
transaction{ transaction_a },
ledger{ ledger },
result{ 0 }
{
}
@ -721,9 +721,9 @@ void representative_visitor::compute (nano::block_hash const & hash_a)
current = hash_a;
while (result.is_zero ())
{
auto block (store.block.get (transaction, current));
debug_assert (block != nullptr);
block->visit (*this);
auto block_l = ledger.block (transaction, current);
debug_assert (block_l != nullptr);
block_l->visit (*this);
}
}
@ -840,9 +840,9 @@ nano::uint128_t nano::ledger::balance (store::transaction const & transaction, n
{
return 0;
}
auto block = store.block.get (transaction, hash);
debug_assert (block != nullptr);
return balance (*block);
auto block_l = block (transaction, hash);
debug_assert (block_l != nullptr);
return balance (*block_l);
}
nano::uint128_t nano::ledger::balance_safe (store::transaction const & transaction_a, nano::block_hash const & hash_a, bool & error_a) const
@ -860,6 +860,11 @@ nano::uint128_t nano::ledger::balance_safe (store::transaction const & transacti
return result;
}
std::shared_ptr<nano::block> nano::ledger::block (store::transaction const & transaction, nano::block_hash const & hash) const
{
return store.block.get (transaction, hash);
}
// Balance for an account by account number
nano::uint128_t nano::ledger::account_balance (store::transaction const & transaction_a, nano::account const & account_a, bool only_confirmed_a)
{
@ -936,7 +941,7 @@ nano::block_hash nano::ledger::representative (store::transaction const & transa
nano::block_hash nano::ledger::representative_calculated (store::transaction const & transaction_a, nano::block_hash const & hash_a)
{
representative_visitor visitor (transaction_a, store);
representative_visitor visitor (transaction_a, *this);
visitor.compute (hash_a);
return visitor.result;
}
@ -969,10 +974,10 @@ std::string nano::ledger::block_text (nano::block_hash const & hash_a)
{
std::string result;
auto transaction (store.tx_begin_read ());
auto block (store.block.get (transaction, hash_a));
if (block != nullptr)
auto block_l = block (transaction, hash_a);
if (block_l != nullptr)
{
block->serialize_json (result);
block_l->serialize_json (result);
}
return result;
}
@ -1111,9 +1116,9 @@ bool nano::ledger::rollback (store::write_transaction const & transaction_a, nan
{
auto info = account_info (transaction_a, account_l);
debug_assert (info);
auto block (store.block.get (transaction_a, info->head));
list_a.push_back (block);
block->visit (rollback);
auto block_l = block (transaction_a, info->head);
list_a.push_back (block_l);
block_l->visit (rollback);
error = rollback.error;
if (!error)
{
@ -1148,9 +1153,9 @@ nano::account nano::ledger::account (nano::block const & block) const
nano::account nano::ledger::account (store::transaction const & transaction, nano::block_hash const & hash) const
{
auto block = store.block.get (transaction, hash);
debug_assert (block != nullptr);
return account (*block);
auto block_l = block (transaction, hash);
debug_assert (block_l != nullptr);
return account (*block_l);
}
nano::account nano::ledger::account_safe (store::transaction const & transaction_a, nano::block_hash const & hash_a, bool & error_a) const
@ -1161,10 +1166,10 @@ nano::account nano::ledger::account_safe (store::transaction const & transaction
}
else
{
auto block (store.block.get (transaction_a, hash_a));
if (block != nullptr)
auto block_l = block (transaction_a, hash_a);
if (block_l != nullptr)
{
return account (*block);
return account (*block_l);
}
else
{
@ -1176,10 +1181,10 @@ nano::account nano::ledger::account_safe (store::transaction const & transaction
nano::account nano::ledger::account_safe (store::transaction const & transaction, nano::block_hash const & hash) const
{
auto block = store.block.get (transaction, hash);
if (block)
auto block_l = block (transaction, hash);
if (block_l)
{
return account (*block);
return account (*block_l);
}
else
{
@ -1194,18 +1199,18 @@ std::optional<nano::account_info> nano::ledger::account_info (store::transaction
nano::uint128_t nano::ledger::amount (store::transaction const & transaction_a, nano::block_hash const & hash_a)
{
auto block (store.block.get (transaction_a, hash_a));
auto block_l = block (transaction_a, hash_a);
auto block_balance (balance (transaction_a, hash_a));
auto previous_balance (balance (transaction_a, block->previous ()));
auto previous_balance (balance (transaction_a, block_l->previous ()));
return block_balance > previous_balance ? block_balance - previous_balance : previous_balance - block_balance;
}
nano::uint128_t nano::ledger::amount_safe (store::transaction const & transaction_a, nano::block_hash const & hash_a, bool & error_a) const
{
auto block (store.block.get (transaction_a, hash_a));
debug_assert (block);
auto block_l = block (transaction_a, hash_a);
debug_assert (block_l);
auto block_balance (balance (transaction_a, hash_a));
auto previous_balance (balance_safe (transaction_a, block->previous (), error_a));
auto previous_balance (balance_safe (transaction_a, block_l->previous (), error_a));
return error_a ? 0 : block_balance > previous_balance ? block_balance - previous_balance
: previous_balance - block_balance;
}
@ -1237,10 +1242,10 @@ void nano::ledger::dump_account_chain (nano::account const & account_a, std::ost
auto hash (latest (transaction, account_a));
while (!hash.is_zero ())
{
auto block (store.block.get (transaction, hash));
debug_assert (block != nullptr);
auto block_l = block (transaction, hash);
debug_assert (block_l != nullptr);
stream << hash.to_string () << std::endl;
hash = block->previous ();
hash = block_l->previous ();
}
}
@ -1328,7 +1333,7 @@ std::shared_ptr<nano::block> nano::ledger::find_receive_block_by_send_hash (stor
{
return nullptr;
}
auto possible_receive_block = store.block.get (transaction, info.frontier);
auto possible_receive_block = block (transaction, info.frontier);
// walk down the chain until the source field of a receive block matches the send block hash
while (possible_receive_block != nullptr)
@ -1355,7 +1360,7 @@ std::shared_ptr<nano::block> nano::ledger::find_receive_block_by_send_hash (stor
break;
}
possible_receive_block = store.block.get (transaction, possible_receive_block->previous ());
possible_receive_block = block (transaction, possible_receive_block->previous ());
}
return result;
@ -1423,7 +1428,7 @@ std::shared_ptr<nano::block> nano::ledger::successor (store::transaction const &
std::shared_ptr<nano::block> result;
if (!successor.is_zero ())
{
result = store.block.get (transaction_a, successor);
result = block (transaction_a, successor);
}
debug_assert (successor.is_zero () || result != nullptr);
return result;
@ -1434,12 +1439,12 @@ std::shared_ptr<nano::block> nano::ledger::forked_block (store::transaction cons
debug_assert (!store.block.exists (transaction_a, block_a.hash ()));
auto root (block_a.root ());
debug_assert (store.block.exists (transaction_a, root.as_block_hash ()) || store.account.exists (transaction_a, root.as_account ()));
auto result (store.block.get (transaction_a, store.block.successor (transaction_a, root.as_block_hash ())));
auto result = block (transaction_a, store.block.successor (transaction_a, root.as_block_hash ()));
if (result == nullptr)
{
auto info = account_info (transaction_a, root.as_account ());
debug_assert (info);
result = store.block.get (transaction_a, info->open_block);
result = block (transaction_a, info->open_block);
debug_assert (result != nullptr);
}
return result;
@ -1450,7 +1455,7 @@ std::shared_ptr<nano::block> nano::ledger::head_block (store::transaction const
auto info = store.account.get (transaction, account);
if (info)
{
return store.block.get (transaction, info->head);
return block (transaction, info->head);
}
return nullptr;
}
@ -1461,12 +1466,12 @@ bool nano::ledger::block_confirmed (store::transaction const & transaction_a, na
{
return true;
}
auto block = store.block.get (transaction_a, hash_a);
if (block)
auto block_l = block (transaction_a, hash_a);
if (block_l)
{
nano::confirmation_height_info confirmation_height_info;
store.confirmation_height.get (transaction_a, block->account ().is_zero () ? block->sideband ().account : block->account (), confirmation_height_info);
auto confirmed (confirmation_height_info.height >= block->sideband ().height);
store.confirmation_height.get (transaction_a, block_l->account ().is_zero () ? block_l->sideband ().account : block_l->account (), confirmation_height_info);
auto confirmed (confirmation_height_info.height >= block_l->sideband ().height);
return confirmed;
}
return false;
@ -1478,12 +1483,12 @@ uint64_t nano::ledger::pruning_action (store::write_transaction & transaction_a,
nano::block_hash hash (hash_a);
while (!hash.is_zero () && hash != constants.genesis->hash ())
{
auto block (store.block.get (transaction_a, hash));
if (block != nullptr)
auto block_l = block (transaction_a, hash);
if (block_l != nullptr)
{
store.block.del (transaction_a, hash);
store.pruned.put (transaction_a, hash);
hash = block->previous ();
hash = block_l->previous ();
++pruned_count;
++cache.pruned_count;
if (pruned_count % batch_size_a == 0)
@ -1685,18 +1690,18 @@ nano::epoch nano::ledger::version (nano::block const & block)
nano::epoch nano::ledger::version (store::transaction const & transaction, nano::block_hash const & hash) const
{
auto block = store.block.get (transaction, hash);
if (block == nullptr)
auto block_l = block (transaction, hash);
if (block_l == nullptr)
{
return nano::epoch::epoch_0;
}
return version (*block);
return version (*block_l);
}
uint64_t nano::ledger::height (store::transaction const & transaction, nano::block_hash const & hash) const
{
auto block = store.block.get (transaction, hash);
return block->sideband ().height;
auto block_l = block (transaction, hash);
return block_l->sideband ().height;
}
nano::uncemented_info::uncemented_info (nano::block_hash const & cemented_frontier, nano::block_hash const & frontier, nano::account const & account) :

1
nano/secure/ledger.hpp
View file

@ -51,6 +51,7 @@ public:
static nano::uint128_t balance (nano::block const & block);
nano::uint128_t balance (store::transaction const &, nano::block_hash const &) const;
nano::uint128_t balance_safe (store::transaction const &, nano::block_hash const &, bool &) const;
std::shared_ptr<nano::block> block (store::transaction const & transaction, nano::block_hash const & hash) const;
nano::uint128_t account_balance (store::transaction const &, nano::account const &, bool = false);
nano::uint128_t account_receivable (store::transaction const &, nano::account const &, bool = false);
nano::uint128_t weight (nano::account const &);

4
nano/slow_test/node.cpp
View file

@ -100,7 +100,7 @@ TEST (system, receive_while_synchronizing)
node1->workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::milliseconds (200), ([&system, &key] () {
auto hash (system.wallet (0)->send_sync (nano::dev::genesis_key.pub, key.pub, system.nodes[0]->config.receive_minimum.number ()));
auto transaction (system.nodes[0]->store.tx_begin_read ());
auto block (system.nodes[0]->store.block.get (transaction, hash));
auto block = system.nodes[0]->ledger.block (transaction, hash);
std::string block_text;
block->serialize_json (block_text);
}));
@ -2162,7 +2162,7 @@ TEST (node, wallet_create_block_confirm_conflicts)
// Call block confirm on the top level send block which will confirm everything underneath on both accounts.
{
auto block = node->store.block.get (node->store.tx_begin_read (), latest);
auto block = node->ledger.block (node->store.tx_begin_read (), latest);
node->scheduler.manual.push (block);
std::shared_ptr<nano::election> election;
ASSERT_TIMELY (10s, (election = node->active.election (block->qualified_root ())) != nullptr);

2
nano/test_common/system.cpp
View file

@ -416,7 +416,7 @@ void nano::test::system::generate_receive (nano::node & node_a)
if (i != node_a.store.pending.end ())
{
nano::pending_key const & send_hash (i->first);
send_block = node_a.store.block.get (transaction, send_hash.hash);
send_block = node_a.ledger.block (transaction, send_hash.hash);
}
}
if (send_block != nullptr)