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

Cleanup nano::process_return (#2849)

Browse source
This commit is contained in:
Sergey Kroshnin 2020-08-03 20:51:48 +03:00 • committed by GitHub
commit 0f4ba5c160
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
4 changed files with 27 additions and 45 deletions
Download patch file Download diff file Expand all files Collapse all files

16
nano/core_test/ledger.cpp
View file

@ -113,8 +113,7 @@ TEST (ledger, process_send)
ASSERT_TRUE (store->frontier_get (transaction, info1.head).is_zero ());
ASSERT_EQ (nano::test_genesis_key.pub, store->frontier_get (transaction, hash1));
ASSERT_EQ (nano::process_result::progress, return1.code);
ASSERT_EQ (nano::test_genesis_key.pub, return1.account);
ASSERT_EQ (nano::genesis_amount - 50, return1.amount.number ());
ASSERT_EQ (nano::test_genesis_key.pub, store->block_account_calculated (send));
ASSERT_EQ (50, ledger.account_balance (transaction, nano::test_genesis_key.pub));
ASSERT_EQ (nano::genesis_amount - 50, ledger.account_pending (transaction, key2.pub));
nano::account_info info2;
@ -136,8 +135,8 @@ TEST (ledger, process_send)
ASSERT_EQ (1, open.sideband ().height);
ASSERT_EQ (nano::genesis_amount - 50, ledger.amount (transaction, hash2));
ASSERT_EQ (nano::process_result::progress, return2.code);
ASSERT_EQ (key2.pub, return2.account);
ASSERT_EQ (nano::genesis_amount - 50, return2.amount.number ());
ASSERT_EQ (key2.pub, store->block_account_calculated (open));
ASSERT_EQ (nano::genesis_amount - 50, ledger.amount (transaction, hash2));
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));
@ -210,11 +209,11 @@ TEST (ledger, process_receive)
nano::block_hash hash2 (open.hash ());
auto return1 (ledger.process (transaction, open));
ASSERT_EQ (nano::process_result::progress, return1.code);
ASSERT_EQ (key2.pub, return1.account);
ASSERT_EQ (key2.pub, store->block_account_calculated (open));
ASSERT_EQ (key2.pub, open.sideband ().account);
ASSERT_EQ (nano::genesis_amount - 50, open.sideband ().balance.number ());
ASSERT_EQ (1, open.sideband ().height);
ASSERT_EQ (nano::genesis_amount - 50, return1.amount.number ());
ASSERT_EQ (nano::genesis_amount - 50, ledger.amount (transaction, hash2));
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 ());
@ -230,8 +229,7 @@ TEST (ledger, process_receive)
ASSERT_TRUE (store->frontier_get (transaction, hash2).is_zero ());
ASSERT_EQ (key2.pub, store->frontier_get (transaction, hash4));
ASSERT_EQ (nano::process_result::progress, return2.code);
ASSERT_EQ (key2.pub, return2.account);
ASSERT_EQ (25, return2.amount.number ());
ASSERT_EQ (key2.pub, store->block_account_calculated (receive));
ASSERT_EQ (hash4, ledger.latest (transaction, key2.pub));
ASSERT_EQ (25, ledger.account_balance (transaction, nano::test_genesis_key.pub));
ASSERT_EQ (0, ledger.account_pending (transaction, key2.pub));
@ -439,7 +437,7 @@ TEST (ledger, representative_change)
ASSERT_TRUE (store->frontier_get (transaction, info1.head).is_zero ());
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 (nano::test_genesis_key.pub, store->block_account_calculated (block));
ASSERT_EQ (0, ledger.weight (nano::test_genesis_key.pub));
ASSERT_EQ (nano::genesis_amount, ledger.weight (key2.pub));
nano::account_info info2;

29
nano/node/blockprocessor.cpp
View file

@ -327,22 +327,23 @@ void nano::block_processor::process_live (nano::block_hash const & hash_a, std::
nano::process_return nano::block_processor::process_one (nano::write_transaction const & transaction_a, block_post_events & events_a, nano::unchecked_info info_a, const bool watch_work_a, nano::block_origin const origin_a)
{
nano::process_return result;
auto hash (info_a.block->hash ());
result = node.ledger.process (transaction_a, *(info_a.block), info_a.verified);
auto block (info_a.block);
auto hash (block->hash ());
result = node.ledger.process (transaction_a, *block, info_a.verified);
switch (result.code)
{
case nano::process_result::progress:
{
release_assert (info_a.account.is_zero () || info_a.account == result.account);
release_assert (info_a.account.is_zero () || info_a.account == node.store.block_account_calculated (*block));
if (node.config.logging.ledger_logging ())
{
std::string block;
info_a.block->serialize_json (block, node.config.logging.single_line_record ());
node.logger.try_log (boost::str (boost::format ("Processing block %1%: %2%") % hash.to_string () % block));
std::string block_string;
block->serialize_json (block_string, node.config.logging.single_line_record ());
node.logger.try_log (boost::str (boost::format ("Processing block %1%: %2%") % hash.to_string () % block_string));
}
if (info_a.modified > nano::seconds_since_epoch () - 300 && node.block_arrival.recent (hash))
{
events_a.events.emplace_back ([this, hash, block = info_a.block, result, watch_work_a, origin_a]() { process_live (hash, block, result, watch_work_a, origin_a); });
events_a.events.emplace_back ([this, hash, block, result, watch_work_a, origin_a]() { process_live (hash, block, result, watch_work_a, origin_a); });
}
queue_unchecked (transaction_a, hash);
break;
@ -359,7 +360,7 @@ nano::process_return nano::block_processor::process_one (nano::write_transaction
info_a.modified = nano::seconds_since_epoch ();
}
nano::unchecked_key unchecked_key (info_a.block->previous (), hash);
nano::unchecked_key unchecked_key (block->previous (), hash);
auto exists = node.store.unchecked_exists (transaction_a, unchecked_key);
node.store.unchecked_put (transaction_a, unchecked_key, info_a);
if (!exists)
@ -383,7 +384,7 @@ nano::process_return nano::block_processor::process_one (nano::write_transaction
info_a.modified = nano::seconds_since_epoch ();
}
nano::unchecked_key unchecked_key (node.ledger.block_source (transaction_a, *(info_a.block)), hash);
nano::unchecked_key unchecked_key (node.ledger.block_source (transaction_a, *block), hash);
auto exists = node.store.unchecked_exists (transaction_a, unchecked_key);
node.store.unchecked_put (transaction_a, unchecked_key, info_a);
if (!exists)
@ -401,7 +402,7 @@ nano::process_return nano::block_processor::process_one (nano::write_transaction
{
node.logger.try_log (boost::str (boost::format ("Old for: %1%") % hash.to_string ()));
}
process_old (transaction_a, info_a.block, origin_a);
process_old (transaction_a, block, origin_a);
node.stats.inc (nano::stat::type::ledger, nano::stat::detail::old);
break;
}
@ -432,11 +433,11 @@ nano::process_return nano::block_processor::process_one (nano::write_transaction
}
case nano::process_result::fork:
{
node.process_fork (transaction_a, info_a.block, info_a.modified);
node.process_fork (transaction_a, block, info_a.modified);
node.stats.inc (nano::stat::type::ledger, nano::stat::detail::fork);
if (node.config.logging.ledger_logging ())
{
node.logger.try_log (boost::str (boost::format ("Fork for: %1% root: %2%") % hash.to_string () % info_a.block->root ().to_string ()));
node.logger.try_log (boost::str (boost::format ("Fork for: %1% root: %2%") % hash.to_string () % block->root ().to_string ()));
}
break;
}
@ -465,7 +466,7 @@ nano::process_return nano::block_processor::process_one (nano::write_transaction
{
if (node.config.logging.ledger_logging ())
{
node.logger.try_log (boost::str (boost::format ("Block %1% cannot follow predecessor %2%") % hash.to_string () % info_a.block->previous ().to_string ()));
node.logger.try_log (boost::str (boost::format ("Block %1% cannot follow predecessor %2%") % hash.to_string () % block->previous ().to_string ()));
}
break;
}
@ -473,7 +474,7 @@ nano::process_return nano::block_processor::process_one (nano::write_transaction
{
if (node.config.logging.ledger_logging ())
{
node.logger.try_log (boost::str (boost::format ("Insufficient work for %1% : %2% (difficulty %3%)") % hash.to_string () % nano::to_string_hex (info_a.block->block_work ()) % nano::to_string_hex (info_a.block->difficulty ())));
node.logger.try_log (boost::str (boost::format ("Insufficient work for %1% : %2% (difficulty %3%)") % hash.to_string () % nano::to_string_hex (block->block_work ()) % nano::to_string_hex (block->difficulty ())));
}
break;
}

4
nano/secure/common.hpp
View file

@ -322,10 +322,6 @@ class process_return final
{
public:
nano::process_result code;
nano::account account;
nano::amount amount;
nano::account pending_account;
boost::optional<bool> state_is_send;
nano::signature_verification verified;
nano::amount previous_balance;
};

23
nano/secure/ledger.cpp
View file

@ -275,7 +275,7 @@ void ledger_processor::state_block_impl (nano::state_block & block_a)
{
nano::epoch epoch (nano::epoch::epoch_0);
nano::account_info info;
result.amount = block_a.hashables.balance;
nano::amount amount (block_a.hashables.balance);
auto is_send (false);
auto is_receive (false);
auto account_error (ledger.store.account_get (transaction, block_a.hashables.account, info));
@ -292,7 +292,7 @@ void ledger_processor::state_block_impl (nano::state_block & block_a)
{
is_send = block_a.hashables.balance < info.balance;
is_receive = !is_send && !block_a.hashables.link.is_zero ();
result.amount = is_send ? (info.balance.number () - result.amount.number ()) : (result.amount.number () - info.balance.number ());
amount = is_send ? (info.balance.number () - amount.number ()) : (amount.number () - info.balance.number ());
result.code = block_a.hashables.previous == info.head ? nano::process_result::progress : nano::process_result::fork; // Is the previous block the account's head block? (Ambigious)
}
}
@ -322,7 +322,7 @@ void ledger_processor::state_block_impl (nano::state_block & block_a)
result.code = ledger.store.pending_get (transaction, key, pending) ? nano::process_result::unreceivable : nano::process_result::progress; // Has this source already been received (Malformed)
if (result.code == nano::process_result::progress)
{
result.code = result.amount == pending.amount ? nano::process_result::progress : nano::process_result::balance_mismatch;
result.code = amount == pending.amount ? nano::process_result::progress : nano::process_result::balance_mismatch;
epoch = std::max (epoch, pending.epoch);
}
}
@ -330,7 +330,7 @@ void ledger_processor::state_block_impl (nano::state_block & block_a)
else
{
// If there's no link, the balance must remain the same, only the representative can change
result.code = result.amount.is_zero () ? nano::process_result::progress : nano::process_result::balance_mismatch;
result.code = amount.is_zero () ? nano::process_result::progress : nano::process_result::balance_mismatch;
}
}
}
@ -355,7 +355,7 @@ void ledger_processor::state_block_impl (nano::state_block & block_a)
if (is_send)
{
nano::pending_key key (block_a.hashables.link, hash);
nano::pending_info info (block_a.hashables.account, result.amount.number (), epoch);
nano::pending_info info (block_a.hashables.account, amount.number (), epoch);
ledger.store.pending_put (transaction, key, info);
}
else if (!block_a.hashables.link.is_zero ())
@ -369,8 +369,6 @@ void ledger_processor::state_block_impl (nano::state_block & block_a)
{
ledger.store.frontier_del (transaction, info.head);
}
// Frontier table is unnecessary for state blocks and this also prevents old blocks from being inserted on top of state blocks
result.account = block_a.hashables.account;
}
}
}
@ -440,8 +438,6 @@ void ledger_processor::epoch_block_impl (nano::state_block & block_a)
if (result.code == nano::process_result::progress)
{
ledger.stats.inc (nano::stat::type::ledger, nano::stat::detail::epoch_block);
result.account = block_a.hashables.account;
result.amount = 0;
block_a.sideband_set (nano::block_sideband (block_a.hashables.account /* unused */, 0, 0 /* unused */, info.block_count + 1, nano::seconds_since_epoch (), block_details));
ledger.store.block_put (transaction, hash, block_a);
nano::account_info new_info (hash, block_a.representative (), info.open_block.is_zero () ? hash : info.open_block, info.balance, nano::seconds_since_epoch (), info.block_count + 1, epoch);
@ -515,8 +511,6 @@ void ledger_processor::change_block (nano::change_block & block_a)
ledger.change_latest (transaction, account, info, new_info);
ledger.store.frontier_del (transaction, block_a.hashables.previous);
ledger.store.frontier_put (transaction, hash, account);
result.account = account;
result.amount = 0;
result.previous_balance = info.balance;
ledger.stats.inc (nano::stat::type::ledger, nano::stat::detail::change);
}
@ -575,9 +569,6 @@ void ledger_processor::send_block (nano::send_block & block_a)
ledger.store.pending_put (transaction, nano::pending_key (block_a.hashables.destination, hash), { account, amount, nano::epoch::epoch_0 });
ledger.store.frontier_del (transaction, block_a.hashables.previous);
ledger.store.frontier_put (transaction, hash, account);
result.account = account;
result.amount = amount;
result.pending_account = block_a.hashables.destination;
result.previous_balance = info.balance;
ledger.stats.inc (nano::stat::type::ledger, nano::stat::detail::send);
}
@ -649,8 +640,6 @@ void ledger_processor::receive_block (nano::receive_block & block_a)
ledger.cache.rep_weights.representation_add (info.representative, pending.amount.number ());
ledger.store.frontier_del (transaction, block_a.hashables.previous);
ledger.store.frontier_put (transaction, hash, account);
result.account = account;
result.amount = pending.amount;
result.previous_balance = info.balance;
ledger.stats.inc (nano::stat::type::ledger, nano::stat::detail::receive);
}
@ -718,8 +707,6 @@ void ledger_processor::open_block (nano::open_block & block_a)
ledger.change_latest (transaction, block_a.hashables.account, info, new_info);
ledger.cache.rep_weights.representation_add (block_a.representative (), pending.amount.number ());
ledger.store.frontier_put (transaction, hash, block_a.hashables.account);
result.account = block_a.hashables.account;
result.amount = pending.amount;
result.previous_balance = 0;
ledger.stats.inc (nano::stat::type::ledger, nano::stat::detail::open);
}