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

Move ledger::latest on to ledger set head

Browse source
This commit is contained in:
Colin LeMahieu 2024-03-11 15:26:53 +00:00
commit cafaadfeee
No known key found for this signature in database
GPG key ID: 43708520C8DFB938
16 changed files with 45 additions and 53 deletions
Download patch file Download diff file Expand all files Collapse all files

14
nano/core_test/ledger.cpp
View file

@ -267,7 +267,7 @@ TEST (ledger, process_receive)
ASSERT_EQ (25, ledger.amount (transaction, hash4));
ASSERT_EQ (nano::block_status::progress, return2);
ASSERT_EQ (key2.pub, receive->account ());
ASSERT_EQ (hash4, ledger.latest (transaction, key2.pub));
ASSERT_EQ (hash4, ledger.any.account_head (transaction, key2.pub));
ASSERT_EQ (25, ledger.account_balance (transaction, nano::dev::genesis_key.pub));
ASSERT_EQ (0, ledger.account_receivable (transaction, key2.pub));
ASSERT_EQ (nano::dev::constants.genesis_amount - 25, ledger.account_balance (transaction, key2.pub));
@ -278,7 +278,7 @@ TEST (ledger, process_receive)
ASSERT_EQ (25, ledger.account_receivable (transaction, key2.pub));
ASSERT_EQ (nano::dev::constants.genesis_amount - 50, ledger.account_balance (transaction, key2.pub));
ASSERT_EQ (nano::dev::constants.genesis_amount - 50, ledger.weight (key3.pub));
ASSERT_EQ (hash2, ledger.latest (transaction, key2.pub));
ASSERT_EQ (hash2, ledger.any.account_head (transaction, key2.pub));
auto pending1 = ledger.pending_info (transaction, nano::pending_key (key2.pub, hash3));
ASSERT_TRUE (pending1);
ASSERT_EQ (nano::dev::genesis_key.pub, pending1->source);
@ -318,7 +318,7 @@ TEST (ledger, rollback_receiver)
.build ();
nano::block_hash hash2 (open->hash ());
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, open));
ASSERT_EQ (hash2, ledger.latest (transaction, key2.pub));
ASSERT_EQ (hash2, ledger.any.account_head (transaction, key2.pub));
ASSERT_EQ (50, ledger.account_balance (transaction, nano::dev::genesis_key.pub));
ASSERT_EQ (nano::dev::constants.genesis_amount - 50, ledger.account_balance (transaction, key2.pub));
ASSERT_EQ (50, ledger.weight (nano::dev::genesis_key.pub));
@ -493,7 +493,7 @@ TEST (ledger, representative_genesis)
auto & ledger = ctx.ledger ();
auto & store = ctx.store ();
auto transaction = ledger.tx_begin_write ();
auto latest = ledger.latest (transaction, nano::dev::genesis_key.pub);
auto latest = ledger.any.account_head (transaction, nano::dev::genesis_key.pub);
ASSERT_FALSE (latest.is_zero ());
ASSERT_EQ (nano::dev::genesis->hash (), ledger.representative (transaction, latest));
}
@ -2096,7 +2096,7 @@ TEST (ledger, latest_empty)
auto & store = ctx.store ();
nano::keypair key;
auto transaction = ledger.tx_begin_read ();
auto latest = ledger.latest (transaction, key.pub);
auto latest = ledger.any.account_head (transaction, key.pub);
ASSERT_TRUE (latest.is_zero ());
}
@ -2109,7 +2109,7 @@ TEST (ledger, latest_root)
auto & pool = ctx.pool ();
nano::keypair key;
ASSERT_EQ (key.pub, ledger.latest_root (transaction, key.pub).as_account ());
auto hash1 = ledger.latest (transaction, nano::dev::genesis_key.pub);
auto hash1 = ledger.any.account_head (transaction, nano::dev::genesis_key.pub);
nano::block_builder builder;
auto send = builder
.send ()
@ -4801,7 +4801,7 @@ TEST (ledger, cache)
};
nano::keypair key;
auto const latest = ledger.latest (ledger.tx_begin_read (), nano::dev::genesis_key.pub);
auto const latest = ledger.any.account_head (ledger.tx_begin_read (), nano::dev::genesis_key.pub);
auto send = builder.state ()
.account (nano::dev::genesis_key.pub)
.previous (latest)

12
nano/core_test/ledger_confirm.cpp
View file

@ -213,14 +213,14 @@ TEST (ledger_confirm, multiple_accounts)
// The accounts for key1 and key2 have 1 more block in the chain than is confirmed.
// So this can be rolled back, but the one before that cannot. Check that this is the case
ASSERT_FALSE (node->ledger.rollback (transaction, node->ledger.latest (transaction, key2.pub)));
ASSERT_FALSE (node->ledger.rollback (transaction, node->ledger.latest (transaction, key1.pub)));
ASSERT_TRUE (node->ledger.rollback (transaction, node->ledger.latest (transaction, key1.pub)));
ASSERT_TRUE (node->ledger.rollback (transaction, node->ledger.latest (transaction, key2.pub)));
ASSERT_FALSE (node->ledger.rollback (transaction, node->ledger.any.account_head (transaction, key2.pub)));
ASSERT_FALSE (node->ledger.rollback (transaction, node->ledger.any.account_head (transaction, key1.pub)));
ASSERT_TRUE (node->ledger.rollback (transaction, node->ledger.any.account_head (transaction, key1.pub)));
ASSERT_TRUE (node->ledger.rollback (transaction, node->ledger.any.account_head (transaction, key2.pub)));
// Confirm the other latest can't be rolled back either
ASSERT_TRUE (node->ledger.rollback (transaction, node->ledger.latest (transaction, key3.pub)));
ASSERT_TRUE (node->ledger.rollback (transaction, node->ledger.latest (transaction, nano::dev::genesis_key.pub)));
ASSERT_TRUE (node->ledger.rollback (transaction, node->ledger.any.account_head (transaction, key3.pub)));
ASSERT_TRUE (node->ledger.rollback (transaction, node->ledger.any.account_head (transaction, nano::dev::genesis_key.pub)));
// Attempt some others which have been cemented
ASSERT_TRUE (node->ledger.rollback (transaction, open1->hash ()));

8
nano/core_test/network.cpp
View file

@ -194,12 +194,12 @@ TEST (network, send_discarded_publish)
{
auto transaction = node1.ledger.tx_begin_read ();
node1.network.flood_block (block);
ASSERT_EQ (nano::dev::genesis->hash (), node1.ledger.latest (transaction, nano::dev::genesis_key.pub));
ASSERT_EQ (nano::dev::genesis->hash (), node1.ledger.any.account_head (transaction, nano::dev::genesis_key.pub));
ASSERT_EQ (nano::dev::genesis->hash (), node2.latest (nano::dev::genesis_key.pub));
}
ASSERT_TIMELY (10s, node2.stats.count (nano::stat::type::message, nano::stat::detail::publish, nano::stat::dir::in) != 0);
auto transaction = node1.ledger.tx_begin_read ();
ASSERT_EQ (nano::dev::genesis->hash (), node1.ledger.latest (transaction, nano::dev::genesis_key.pub));
ASSERT_EQ (nano::dev::genesis->hash (), node1.ledger.any.account_head (transaction, nano::dev::genesis_key.pub));
ASSERT_EQ (nano::dev::genesis->hash (), node2.latest (nano::dev::genesis_key.pub));
}
@ -220,12 +220,12 @@ TEST (network, send_invalid_publish)
{
auto transaction = node1.ledger.tx_begin_read ();
node1.network.flood_block (block);
ASSERT_EQ (nano::dev::genesis->hash (), node1.ledger.latest (transaction, nano::dev::genesis_key.pub));
ASSERT_EQ (nano::dev::genesis->hash (), node1.ledger.any.account_head (transaction, nano::dev::genesis_key.pub));
ASSERT_EQ (nano::dev::genesis->hash (), node2.latest (nano::dev::genesis_key.pub));
}
ASSERT_TIMELY (10s, node2.stats.count (nano::stat::type::message, nano::stat::detail::publish, nano::stat::dir::in) != 0);
auto transaction = node1.ledger.tx_begin_read ();
ASSERT_EQ (nano::dev::genesis->hash (), node1.ledger.latest (transaction, nano::dev::genesis_key.pub));
ASSERT_EQ (nano::dev::genesis->hash (), node1.ledger.any.account_head (transaction, nano::dev::genesis_key.pub));
ASSERT_EQ (nano::dev::genesis->hash (), node2.latest (nano::dev::genesis_key.pub));
}

2
nano/core_test/wallet.cpp
View file

@ -1189,7 +1189,7 @@ TEST (wallet, search_receivable)
ASSERT_EQ (2, node.ledger.block_count ());
ASSERT_FALSE (wallet.search_receivable (wallet.wallets.tx_begin_read ()));
ASSERT_TIMELY_EQ (3s, node.balance (nano::dev::genesis_key.pub), nano::dev::constants.genesis_amount);
auto receive_hash = node.ledger.latest (node.ledger.tx_begin_read (), nano::dev::genesis_key.pub);
auto receive_hash = node.ledger.any.account_head (node.ledger.tx_begin_read (), nano::dev::genesis_key.pub);
auto receive = node.block (receive_hash);
ASSERT_NE (nullptr, receive);
ASSERT_EQ (receive->sideband ().height, 3);

2
nano/core_test/wallets.cpp
View file

@ -255,7 +255,7 @@ TEST (wallets, search_receivable)
node.wallets.search_receivable (wallet_id);
}
ASSERT_TIMELY_EQ (3s, node.balance (nano::dev::genesis_key.pub), nano::dev::constants.genesis_amount);
auto receive_hash = node.ledger.latest (node.ledger.tx_begin_read (), nano::dev::genesis_key.pub);
auto receive_hash = node.ledger.any.account_head (node.ledger.tx_begin_read (), nano::dev::genesis_key.pub);
auto receive = node.block (receive_hash);
ASSERT_NE (nullptr, receive);
ASSERT_EQ (receive->sideband ().height, 3);

2
nano/node/bootstrap/bootstrap_bulk_pull.cpp
View file

@ -654,7 +654,7 @@ void nano::bulk_pull_account_server::send_frontier ()
auto stream_transaction = node->ledger.tx_begin_read ();
// Get account balance and frontier block hash
auto account_frontier_hash (node->ledger.latest (stream_transaction, request->account));
auto account_frontier_hash (node->ledger.any.account_head (stream_transaction, request->account));
auto account_frontier_balance_int (node->ledger.account_balance (stream_transaction, request->account));
nano::uint128_union account_frontier_balance (account_frontier_balance_int);

14
nano/node/json_handler.cpp
View file

@ -1004,7 +1004,7 @@ void nano::json_handler::accounts_frontiers ()
auto account = account_impl (account_from_request.second.data ());
if (!ec)
{
auto latest = node.ledger.latest (transaction, account);
auto latest = node.ledger.any.account_head (transaction, account);
if (!latest.is_zero ())
{
frontiers.put (account.to_account (), latest.to_string ());
@ -1532,7 +1532,7 @@ void nano::json_handler::block_create ()
if (!ec)
{
existing->second->store.fetch (transaction, account, prv);
previous = node.ledger.latest (block_transaction, account);
previous = node.ledger.any.account_head (block_transaction, account);
balance = node.ledger.account_balance (block_transaction, account);
}
}
@ -1647,7 +1647,7 @@ void nano::json_handler::block_create ()
if (!previous_text.is_initialized () && !balance_text.is_initialized ())
{
auto transaction = node.ledger.tx_begin_read ();
previous = node.ledger.latest (transaction, pub);
previous = node.ledger.any.account_head (transaction, pub);
balance = node.ledger.account_balance (transaction, pub);
}
// Double check current balance if previous block is specified
@ -2670,7 +2670,7 @@ void nano::json_handler::account_history ()
}
else
{
hash = node.ledger.latest (transaction, account);
hash = node.ledger.any.account_head (transaction, account);
}
}
}
@ -3711,7 +3711,7 @@ void nano::json_handler::republish ()
{
if (!node.ledger.pending_info (transaction, nano::pending_key{ destination, hash }))
{
nano::block_hash previous (node.ledger.latest (transaction, destination));
nano::block_hash previous (node.ledger.any.account_head (transaction, destination));
auto block_d = node.ledger.any.block_get (transaction, previous);
nano::block_hash source;
std::vector<nano::block_hash> hashes;
@ -4632,7 +4632,7 @@ void nano::json_handler::wallet_frontiers ()
for (auto i (wallet->store.begin (transaction)), n (wallet->store.end ()); i != n; ++i)
{
nano::account const & account (i->first);
auto latest (node.ledger.latest (block_transaction, account));
auto latest (node.ledger.any.account_head (block_transaction, account));
if (!latest.is_zero ())
{
frontiers.put (account.to_account (), latest.to_string ());
@ -4937,7 +4937,7 @@ void nano::json_handler::wallet_republish ()
for (auto i (wallet->store.begin (transaction)), n (wallet->store.end ()); i != n; ++i)
{
nano::account const & account (i->first);
auto latest (node.ledger.latest (block_transaction, account));
auto latest (node.ledger.any.account_head (block_transaction, account));
std::shared_ptr<nano::block> block;
std::vector<nano::block_hash> hashes;
while (!latest.is_zero () && hashes.size () < count)

2
nano/node/node.cpp
View file

@ -771,7 +771,7 @@ void nano::node::keepalive_preconfigured ()
nano::block_hash nano::node::latest (nano::account const & account_a)
{
return ledger.latest (ledger.tx_begin_read (), account_a);
return ledger.any.account_head (ledger.tx_begin_read (), account_a);
}
nano::uint128_t nano::node::balance (nano::account const & account_a)

4
nano/node/wallet.cpp
View file

@ -910,7 +910,7 @@ std::shared_ptr<nano::block> nano::wallet::change_action (nano::account const &
if (store.valid_password (transaction))
{
auto existing (store.find (transaction, source_a));
if (existing != store.end () && !wallets.node.ledger.latest (block_transaction, source_a).is_zero ())
if (existing != store.end () && !wallets.node.ledger.any.account_head (block_transaction, source_a).is_zero ())
{
auto info = wallets.node.ledger.any.account_get (block_transaction, source_a);
debug_assert (info);
@ -1240,7 +1240,7 @@ uint32_t nano::wallet::deterministic_check (store::transaction const & transacti
auto prv = store.deterministic_key (transaction_a, i);
nano::keypair pair (prv.to_string ());
// Check if account received at least 1 block
auto latest (wallets.node.ledger.latest (block_transaction, pair.pub));
auto latest (wallets.node.ledger.any.account_head (block_transaction, pair.pub));
if (!latest.is_zero ())
{
index = i;

2
nano/qt/qt.cpp
View file

@ -636,7 +636,7 @@ void nano_qt::history::refresh ()
{
auto transaction = ledger.tx_begin_read ();
model->removeRows (0, model->rowCount ());
auto hash (ledger.latest (transaction, account));
auto hash (ledger.any.account_head (transaction, account));
short_text_visitor visitor (transaction, ledger);
for (auto i (0), n (tx_count->value ()); i < n && !hash.is_zero (); ++i)
{

12
nano/qt_test/qt.cpp
View file

@ -533,7 +533,7 @@ TEST (history, short_text)
auto transaction (ledger.tx_begin_write ());
store->initialize (transaction, ledger.cache, ledger.constants);
nano::keypair key;
auto latest (ledger.latest (transaction, nano::dev::genesis_key.pub));
auto latest (ledger.any.account_head (transaction, nano::dev::genesis_key.pub));
auto send = std::make_shared<nano::send_block> (latest, nano::dev::genesis_key.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest));
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send));
auto receive = std::make_shared<nano::receive_block> (send->hash (), send->hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send->hash ()));
@ -573,7 +573,7 @@ TEST (history, pruned_source)
{
auto transaction = ledger.tx_begin_write ();
store->initialize (transaction, ledger.cache, nano::dev::constants);
auto latest (ledger.latest (transaction, nano::dev::genesis_key.pub));
auto latest (ledger.any.account_head (transaction, nano::dev::genesis_key.pub));
auto send1 = std::make_shared<nano::send_block> (latest, nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest));
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1));
auto send2 = std::make_shared<nano::send_block> (send1->hash (), key.pub, nano::dev::constants.genesis_amount - 200, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send1->hash ()));
@ -605,10 +605,10 @@ TEST (history, pruned_source)
// Pruning for state blocks. Previous block is pruned, source is pruned
{
auto transaction = ledger.tx_begin_write ();
auto latest (ledger.latest (transaction, nano::dev::genesis_key.pub));
auto latest (ledger.any.account_head (transaction, nano::dev::genesis_key.pub));
auto send = std::make_shared<nano::state_block> (nano::dev::genesis_key.pub, latest, nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - 200, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest));
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send));
auto latest_key (ledger.latest (transaction, key.pub));
auto latest_key (ledger.any.account_head (transaction, key.pub));
auto receive = std::make_shared<nano::state_block> (key.pub, latest_key, key.pub, 200, send->hash (), key.prv, key.pub, *system.work.generate (latest_key));
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive));
ledger.confirm (transaction, latest);
@ -722,7 +722,7 @@ TEST (wallet, republish)
nano::block_hash hash;
{
auto transaction = system.nodes[0]->ledger.tx_begin_write ();
auto latest (system.nodes[0]->ledger.latest (transaction, nano::dev::genesis_key.pub));
auto latest (system.nodes[0]->ledger.any.account_head (transaction, nano::dev::genesis_key.pub));
auto block = std::make_shared<nano::send_block> (latest, key.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest));
hash = block->hash ();
ASSERT_EQ (nano::block_status::progress, system.nodes[0]->ledger.process (transaction, block));
@ -922,7 +922,7 @@ TEST (wallet, DISABLED_synchronizing)
wallet->start ();
{
auto transaction = system1.nodes[0]->ledger.tx_begin_write ();
auto latest (system1.nodes[0]->ledger.latest (transaction, nano::dev::genesis_key.pub));
auto latest (system1.nodes[0]->ledger.any.account_head (transaction, nano::dev::genesis_key.pub));
auto send = std::make_shared<nano::send_block> (latest, key1, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system1.work.generate (latest));
system1.nodes[0]->ledger.process (transaction, send);
}

4
nano/rpc_test/rpc.cpp
View file

@ -2475,7 +2475,7 @@ TEST (rpc, account_representative_set_epoch_2_insufficient_work)
request.put ("representative", nano::keypair ().pub.to_account ());
// Test that the correct error is given if there is insufficient work
auto latest = node->ledger.latest (node->ledger.tx_begin_read (), nano::dev::genesis_key.pub);
auto latest = node->ledger.any.account_head (node->ledger.tx_begin_read (), nano::dev::genesis_key.pub);
auto insufficient = system.work_generate_limited (latest, min_difficulty, target_difficulty);
request.put ("work", nano::to_string_hex (insufficient));
{
@ -5773,7 +5773,7 @@ TEST (rpc, block_confirmed)
// Open an account directly in the ledger
{
auto transaction = node->ledger.tx_begin_write ();
nano::block_hash latest (node->ledger.latest (transaction, nano::dev::genesis_key.pub));
nano::block_hash latest (node->ledger.any.account_head (transaction, nano::dev::genesis_key.pub));
auto send1 = builder
.send ()
.previous (latest)

13
nano/secure/ledger.cpp
View file

@ -48,7 +48,7 @@ public:
auto pending = ledger.store.pending.get (transaction, key);
while (!error && !pending.has_value ())
{
error = ledger.rollback (transaction, ledger.latest (transaction, block_a.hashables.destination), list);
error = ledger.rollback (transaction, ledger.any.account_head (transaction, block_a.hashables.destination), list);
pending = ledger.store.pending.get (transaction, key);
}
if (!error)
@ -145,7 +145,7 @@ public:
nano::pending_key key (block_a.hashables.link.as_account (), hash);
while (!error && !ledger.pending_info (transaction, key))
{
error = ledger.rollback (transaction, ledger.latest (transaction, block_a.hashables.link.as_account ()), list);
error = ledger.rollback (transaction, ledger.any.account_head (transaction, block_a.hashables.link.as_account ()), list);
}
ledger.store.pending.del (transaction, key);
ledger.stats.inc (nano::stat::type::rollback, nano::stat::detail::send);
@ -1041,13 +1041,6 @@ std::optional<nano::uint128_t> nano::ledger::amount (secure::transaction const &
return block_balance > previous_balance.value () ? block_balance.number () - previous_balance.value ().number () : previous_balance.value ().number () - block_balance.number ();
}
// Return latest block for account
nano::block_hash nano::ledger::latest (secure::transaction const & transaction_a, nano::account const & account_a)
{
auto info = any.account_get (transaction_a, account_a);
return !info ? 0 : info->head;
}
// Return latest root for account, account number if there are no blocks for this account.
nano::root nano::ledger::latest_root (secure::transaction const & transaction_a, nano::account const & account_a)
{
@ -1065,7 +1058,7 @@ nano::root nano::ledger::latest_root (secure::transaction const & transaction_a,
void nano::ledger::dump_account_chain (nano::account const & account_a, std::ostream & stream)
{
auto transaction = tx_begin_read ();
auto hash (latest (transaction, account_a));
auto hash (any.account_head (transaction, account_a));
while (!hash.is_zero ())
{
auto block_l = any.block_get (transaction, hash);

1
nano/secure/ledger.hpp
View file

@ -61,7 +61,6 @@ public:
nano::uint128_t weight_exact (secure::transaction const &, nano::account const &) const;
std::shared_ptr<nano::block> forked_block (secure::transaction const &, nano::block const &);
std::shared_ptr<nano::block> head_block (secure::transaction const &, nano::account const &);
nano::block_hash latest (secure::transaction const &, nano::account const &);
nano::root latest_root (secure::transaction const &, nano::account const &);
nano::block_hash representative (secure::transaction const &, nano::block_hash const &);
nano::block_hash representative_calculated (secure::transaction const &, nano::block_hash const &);

4
nano/slow_test/node.cpp
View file

@ -1985,11 +1985,11 @@ TEST (node, aggressive_flooding)
block = builder.make_block ()
.account (nano::dev::genesis_key.pub)
.representative (nano::dev::genesis_key.pub)
.previous (node1.ledger.latest (transaction, nano::dev::genesis_key.pub))
.previous (node1.ledger.any.account_head (transaction, nano::dev::genesis_key.pub))
.balance (node1.ledger.account_balance (transaction, nano::dev::genesis_key.pub) - 1)
.link (nano::dev::genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node1.work_generate_blocking (node1.ledger.latest (transaction, nano::dev::genesis_key.pub)))
.work (*node1.work_generate_blocking (node1.ledger.any.account_head (transaction, nano::dev::genesis_key.pub)))
.build ();
}
// Processing locally goes through the aggressive block flooding path

2
nano/test_common/system.cpp
View file

@ -303,7 +303,7 @@ std::shared_ptr<nano::state_block> nano::test::upgrade_epoch (nano::work_pool &
auto transaction = ledger_a.tx_begin_write ();
auto dev_genesis_key = nano::dev::genesis_key;
auto account = dev_genesis_key.pub;
auto latest = ledger_a.latest (transaction, account);
auto latest = ledger_a.any.account_head (transaction, account);
auto balance = ledger_a.account_balance (transaction, account);
nano::state_block_builder builder;