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

ledger::account is moved to block::account and block::account which accesses the account field is renamed to block::account_field.

Browse source
This commit is contained in:
Colin LeMahieu 2024-03-06 17:14:00 +00:00
commit a7cab75095
No known key found for this signature in database
GPG key ID: 43708520C8DFB938
24 changed files with 84 additions and 71 deletions
Download patch file Download diff file Expand all files Collapse all files

4
nano/core_test/active_transactions.cpp
View file

@ -1534,7 +1534,7 @@ TEST (active_transactions, allow_limited_overflow)
// Insert the first part of the blocks into normal election scheduler // Insert the first part of the blocks into normal election scheduler
for (auto const & block : blocks1) for (auto const & block : blocks1)
{ {
node.scheduler.priority.activate (block->account ().value (), node.store.tx_begin_read ()); node.scheduler.priority.activate (block->account (), node.store.tx_begin_read ());
} }
// Ensure number of active elections reaches AEC limit and there is no overfill // Ensure number of active elections reaches AEC limit and there is no overfill
@ -1596,7 +1596,7 @@ TEST (active_transactions, allow_limited_overflow_adapt)
// Insert the first part of the blocks into normal election scheduler // Insert the first part of the blocks into normal election scheduler
for (auto const & block : blocks1) for (auto const & block : blocks1)
{ {
node.scheduler.priority.activate (block->account ().value (), node.store.tx_begin_read ()); node.scheduler.priority.activate (block->account (), node.store.tx_begin_read ());
} }
// Ensure number of active elections reaches AEC limit and there is no overfill // Ensure number of active elections reaches AEC limit and there is no overfill

2
nano/core_test/backlog.cpp
View file

@ -33,7 +33,7 @@ TEST (backlog, population)
auto all_activated = [&] () { auto all_activated = [&] () {
nano::lock_guard<nano::mutex> lock{ mutex }; nano::lock_guard<nano::mutex> lock{ mutex };
return std::all_of (blocks.begin (), blocks.end (), [&] (auto const & item) { return std::all_of (blocks.begin (), blocks.end (), [&] (auto const & item) {
return activated.count (item->account ().value ()) != 0; return activated.count (item->account ()) != 0;
}); });
}; };
ASSERT_TIMELY (5s, all_activated ()); ASSERT_TIMELY (5s, all_activated ());

12
nano/core_test/ledger.cpp
View file

@ -113,7 +113,7 @@ TEST (ledger, process_send)
ASSERT_TRUE (store.frontier.get (transaction, info1->head).is_zero ()); ASSERT_TRUE (store.frontier.get (transaction, info1->head).is_zero ());
ASSERT_EQ (nano::dev::genesis_key.pub, store.frontier.get (transaction, hash1)); ASSERT_EQ (nano::dev::genesis_key.pub, store.frontier.get (transaction, hash1));
ASSERT_EQ (nano::block_status::progress, return1); ASSERT_EQ (nano::block_status::progress, return1);
ASSERT_EQ (nano::dev::genesis_key.pub, ledger.account (*send)); ASSERT_EQ (nano::dev::genesis_key.pub, send->account ());
ASSERT_EQ (50, ledger.account_balance (transaction, nano::dev::genesis_key.pub)); ASSERT_EQ (50, ledger.account_balance (transaction, nano::dev::genesis_key.pub));
ASSERT_EQ (nano::dev::constants.genesis_amount - 50, ledger.account_receivable (transaction, key2.pub)); ASSERT_EQ (nano::dev::constants.genesis_amount - 50, ledger.account_receivable (transaction, key2.pub));
auto info2 = ledger.account_info (transaction, nano::dev::genesis_key.pub); auto info2 = ledger.account_info (transaction, nano::dev::genesis_key.pub);
@ -142,7 +142,7 @@ TEST (ledger, process_send)
ASSERT_EQ (1, open->sideband ().height); ASSERT_EQ (1, open->sideband ().height);
ASSERT_EQ (nano::dev::constants.genesis_amount - 50, ledger.amount (transaction, hash2)); ASSERT_EQ (nano::dev::constants.genesis_amount - 50, ledger.amount (transaction, hash2));
ASSERT_EQ (nano::block_status::progress, return2); ASSERT_EQ (nano::block_status::progress, return2);
ASSERT_EQ (key2.pub, ledger.account (*open)); ASSERT_EQ (key2.pub, open->account ());
ASSERT_EQ (nano::dev::constants.genesis_amount - 50, ledger.amount (transaction, hash2)); ASSERT_EQ (nano::dev::constants.genesis_amount - 50, ledger.amount (transaction, hash2));
ASSERT_EQ (key2.pub, store.frontier.get (transaction, hash2)); ASSERT_EQ (key2.pub, store.frontier.get (transaction, hash2));
ASSERT_EQ (nano::dev::constants.genesis_amount - 50, ledger.account_balance (transaction, key2.pub)); ASSERT_EQ (nano::dev::constants.genesis_amount - 50, ledger.account_balance (transaction, key2.pub));
@ -226,7 +226,7 @@ TEST (ledger, process_receive)
nano::block_hash hash2 (open->hash ()); nano::block_hash hash2 (open->hash ());
auto return1 = ledger.process (transaction, open); auto return1 = ledger.process (transaction, open);
ASSERT_EQ (nano::block_status::progress, return1); ASSERT_EQ (nano::block_status::progress, return1);
ASSERT_EQ (key2.pub, ledger.account (*open)); ASSERT_EQ (key2.pub, open->account ());
ASSERT_EQ (key2.pub, open->sideband ().account); ASSERT_EQ (key2.pub, open->sideband ().account);
ASSERT_EQ (nano::dev::constants.genesis_amount - 50, open->sideband ().balance.number ()); ASSERT_EQ (nano::dev::constants.genesis_amount - 50, open->sideband ().balance.number ());
ASSERT_EQ (1, open->sideband ().height); ASSERT_EQ (1, open->sideband ().height);
@ -259,7 +259,7 @@ TEST (ledger, process_receive)
ASSERT_TRUE (store.frontier.get (transaction, hash2).is_zero ()); ASSERT_TRUE (store.frontier.get (transaction, hash2).is_zero ());
ASSERT_EQ (key2.pub, store.frontier.get (transaction, hash4)); ASSERT_EQ (key2.pub, store.frontier.get (transaction, hash4));
ASSERT_EQ (nano::block_status::progress, return2); ASSERT_EQ (nano::block_status::progress, return2);
ASSERT_EQ (key2.pub, ledger.account (*receive)); ASSERT_EQ (key2.pub, receive->account ());
ASSERT_EQ (hash4, ledger.latest (transaction, key2.pub)); ASSERT_EQ (hash4, ledger.latest (transaction, key2.pub));
ASSERT_EQ (25, ledger.account_balance (transaction, nano::dev::genesis_key.pub)); ASSERT_EQ (25, ledger.account_balance (transaction, nano::dev::genesis_key.pub));
ASSERT_EQ (0, ledger.account_receivable (transaction, key2.pub)); ASSERT_EQ (0, ledger.account_receivable (transaction, key2.pub));
@ -526,7 +526,7 @@ TEST (ledger, representative_change)
ASSERT_TRUE (store.frontier.get (transaction, info1->head).is_zero ()); ASSERT_TRUE (store.frontier.get (transaction, info1->head).is_zero ());
ASSERT_EQ (nano::dev::genesis_key.pub, store.frontier.get (transaction, block->hash ())); ASSERT_EQ (nano::dev::genesis_key.pub, store.frontier.get (transaction, block->hash ()));
ASSERT_EQ (nano::block_status::progress, return1); ASSERT_EQ (nano::block_status::progress, return1);
ASSERT_EQ (nano::dev::genesis_key.pub, ledger.account (*block)); ASSERT_EQ (nano::dev::genesis_key.pub, block->account ());
ASSERT_EQ (0, ledger.weight (nano::dev::genesis_key.pub)); ASSERT_EQ (0, ledger.weight (nano::dev::genesis_key.pub));
ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.weight (key2.pub)); ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.weight (key2.pub));
auto info2 = ledger.account_info (transaction, nano::dev::genesis_key.pub); auto info2 = ledger.account_info (transaction, nano::dev::genesis_key.pub);
@ -4052,7 +4052,7 @@ TEST (ledger, epoch_open_pending)
ASSERT_TIMELY_EQ (10s, 1, node1.unchecked.count ()); ASSERT_TIMELY_EQ (10s, 1, node1.unchecked.count ());
ASSERT_FALSE (node1.ledger.block_or_pruned_exists (epoch_open->hash ())); ASSERT_FALSE (node1.ledger.block_or_pruned_exists (epoch_open->hash ()));
// Open block should be inserted into unchecked // Open block should be inserted into unchecked
auto blocks = node1.unchecked.get (nano::hash_or_account (epoch_open->account ().value ()).hash); auto blocks = node1.unchecked.get (nano::hash_or_account (epoch_open->account_field ().value ()).hash);
ASSERT_EQ (blocks.size (), 1); ASSERT_EQ (blocks.size (), 1);
ASSERT_EQ (blocks[0].block->full_hash (), epoch_open->full_hash ()); ASSERT_EQ (blocks[0].block->full_hash (), epoch_open->full_hash ());
// New block to process epoch open // New block to process epoch open

23
nano/lib/blocks.cpp
View file

@ -185,7 +185,24 @@ nano::link const & nano::block::link () const
return link; return link;
} }
std::optional<nano::account> nano::block::account () const nano::account nano::block::account () const noexcept
{
release_assert (has_sideband ());
switch (type ())
{
case block_type::open:
case block_type::state:
return account_field ().value ();
case block_type::change:
case block_type::send:
case block_type::receive:
return sideband ().account;
default:
release_assert (false);
}
}
std::optional<nano::account> nano::block::account_field () const
{ {
return std::nullopt; return std::nullopt;
} }
@ -642,7 +659,7 @@ nano::block_hash const & nano::open_block::previous () const
return result; return result;
} }
std::optional<nano::account> nano::open_block::account () const std::optional<nano::account> nano::open_block::account_field () const
{ {
return hashables.account; return hashables.account;
} }
@ -1212,7 +1229,7 @@ nano::block_hash const & nano::state_block::previous () const
return hashables.previous; return hashables.previous;
} }
std::optional<nano::account> nano::state_block::account () const std::optional<nano::account> nano::state_block::account_field () const
{ {
return hashables.account; return hashables.account;
} }

12
nano/lib/blocks.hpp
View file

@ -64,8 +64,10 @@ public:
void refresh (); void refresh ();
public: // Direct access to the block fields or nullopt if the block type does not have the specified field public: // Direct access to the block fields or nullopt if the block type does not have the specified field
// Returns account field or account from sideband
nano::account account () const noexcept;
// Account field for open/state blocks // Account field for open/state blocks
virtual std::optional<nano::account> account () const; virtual std::optional<nano::account> account_field () const;
protected: protected:
mutable nano::block_hash cached_hash{ 0 }; mutable nano::block_hash cached_hash{ 0 };
@ -213,7 +215,6 @@ public:
uint64_t block_work () const override; uint64_t block_work () const override;
void block_work_set (uint64_t) override; void block_work_set (uint64_t) override;
nano::block_hash const & previous () const override; nano::block_hash const & previous () const override;
std::optional<nano::account> account () const override;
nano::block_hash const & source () const override; nano::block_hash const & source () const override;
nano::root const & root () const override; nano::root const & root () const override;
nano::account const & representative () const override; nano::account const & representative () const override;
@ -235,6 +236,9 @@ public:
uint64_t work; uint64_t work;
static std::size_t constexpr size = nano::open_hashables::size + sizeof (signature) + sizeof (work); static std::size_t constexpr size = nano::open_hashables::size + sizeof (signature) + sizeof (work);
public: // Open block fields
std::optional<nano::account> account_field () const override;
public: // Logging public: // Logging
void operator() (nano::object_stream &) const override; void operator() (nano::object_stream &) const override;
}; };
@ -328,7 +332,6 @@ public:
uint64_t block_work () const override; uint64_t block_work () const override;
void block_work_set (uint64_t) override; void block_work_set (uint64_t) override;
nano::block_hash const & previous () const override; nano::block_hash const & previous () const override;
std::optional<nano::account> account () const override;
nano::root const & root () const override; nano::root const & root () const override;
nano::link const & link () const override; nano::link const & link () const override;
nano::account const & representative () const override; nano::account const & representative () const override;
@ -351,6 +354,9 @@ public:
uint64_t work; uint64_t work;
static std::size_t constexpr size = nano::state_hashables::size + sizeof (signature) + sizeof (work); static std::size_t constexpr size = nano::state_hashables::size + sizeof (signature) + sizeof (work);
public: // State block fields
std::optional<nano::account> account_field () const override;
public: // Logging public: // Logging
void operator() (nano::object_stream &) const override; void operator() (nano::object_stream &) const override;
}; };

2
nano/node/active_transactions.cpp
View file

@ -186,7 +186,7 @@ void nano::active_transactions::notify_observers (nano::election_status const &
void nano::active_transactions::handle_final_votes_confirmation (std::shared_ptr<nano::block> const & block, nano::store::read_transaction const & transaction, nano::election_status_type status) void nano::active_transactions::handle_final_votes_confirmation (std::shared_ptr<nano::block> const & block, nano::store::read_transaction const & transaction, nano::election_status_type status)
{ {
auto account = node.ledger.account (*block); auto account = block->account ();
bool is_canary_not_set = !node.ledger.cache.final_votes_confirmation_canary.load (); bool is_canary_not_set = !node.ledger.cache.final_votes_confirmation_canary.load ();
bool is_canary_account = account == node.network_params.ledger.final_votes_canary_account; bool is_canary_account = account == node.network_params.ledger.final_votes_canary_account;

2
nano/node/blockprocessor.cpp
View file

@ -362,7 +362,7 @@ nano::block_status nano::block_processor::process_one (store::write_transaction
} }
case nano::block_status::gap_epoch_open_pending: case nano::block_status::gap_epoch_open_pending:
{ {
node.unchecked.put (block->account ().value_or (0), block); // Specific unchecked key starting with epoch open block account public key node.unchecked.put (block->account_field ().value_or (0), block); // Specific unchecked key starting with epoch open block account public key
node.stats.inc (nano::stat::type::ledger, nano::stat::detail::gap_source); node.stats.inc (nano::stat::type::ledger, nano::stat::detail::gap_source);
break; break;
} }

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

@ -176,7 +176,7 @@ void nano::bulk_pull_client::received_block (boost::system::error_code ec, std::
// Is block expected? // Is block expected?
bool block_expected (false); bool block_expected (false);
// Unconfirmed head is used only for lazy destinations if legacy bootstrap is not available, see nano::bootstrap_attempt::lazy_destinations_increment (...) // Unconfirmed head is used only for lazy destinations if legacy bootstrap is not available, see nano::bootstrap_attempt::lazy_destinations_increment (...)
bool unconfirmed_account_head = node->flags.disable_legacy_bootstrap && pull_blocks == 0 && pull.retry_limit <= node->network_params.bootstrap.lazy_retry_limit && (expected == pull.account_or_head.as_block_hash ()) && (block->account () == pull.account_or_head.as_account ()); bool unconfirmed_account_head = node->flags.disable_legacy_bootstrap && pull_blocks == 0 && pull.retry_limit <= node->network_params.bootstrap.lazy_retry_limit && (expected == pull.account_or_head.as_block_hash ()) && (block->account_field () == pull.account_or_head.as_account ());
if (hash == expected || unconfirmed_account_head) if (hash == expected || unconfirmed_account_head)
{ {
expected = block->previous (); expected = block->previous ();
@ -188,7 +188,7 @@ void nano::bulk_pull_client::received_block (boost::system::error_code ec, std::
} }
if (pull_blocks == 0 && block_expected) if (pull_blocks == 0 && block_expected)
{ {
known_account = block->account ().value_or (0); known_account = block->account_field ().value_or (0);
} }
if (connection->block_count++ == 0) if (connection->block_count++ == 0)
{ {

6
nano/node/bootstrap_ascending/service.cpp
View file

@ -133,7 +133,7 @@ void nano::bootstrap_ascending::service::inspect (store::transaction const & tx,
{ {
case nano::block_status::progress: case nano::block_status::progress:
{ {
const auto account = ledger.account (block); const auto account = block.account ();
const auto is_send = ledger.is_send (tx, block); const auto is_send = ledger.is_send (tx, block);
// If we've inserted any block in to an account, unmark it as blocked // If we've inserted any block in to an account, unmark it as blocked
@ -167,7 +167,7 @@ void nano::bootstrap_ascending::service::inspect (store::transaction const & tx,
break; break;
case nano::block_status::gap_source: case nano::block_status::gap_source:
{ {
const auto account = block.previous ().is_zero () ? block.account ().value () : ledger.account (tx, block.previous ()).value (); const auto account = block.previous ().is_zero () ? block.account_field ().value () : ledger.account (tx, block.previous ()).value ();
const auto source = block.source ().is_zero () ? block.link ().as_block_hash () : block.source (); const auto source = block.source ().is_zero () ? block.link ().as_block_hash () : block.source ();
// Mark account as blocked because it is missing the source block // Mark account as blocked because it is missing the source block
@ -456,7 +456,7 @@ nano::bootstrap_ascending::service::verify_result nano::bootstrap_ascending::ser
case async_tag::query_type::blocks_by_account: case async_tag::query_type::blocks_by_account:
{ {
// Open & state blocks always contain account field // Open & state blocks always contain account field
if (first->account () != tag.start.as_account ()) if (first->account_field () != tag.start.as_account ())
{ {
// TODO: Stat & log // TODO: Stat & log
return verify_result::invalid; return verify_result::invalid;

2
nano/node/cli.cpp
View file

@ -1324,7 +1324,7 @@ void reset_confirmation_heights (nano::store::write_transaction const & transact
store.confirmation_height.clear (transaction); store.confirmation_height.clear (transaction);
// Then make sure the confirmation height of the genesis account open block is 1 // Then make sure the confirmation height of the genesis account open block is 1
store.confirmation_height.put (transaction, constants.genesis->account ().value (), { 1, constants.genesis->hash () }); store.confirmation_height.put (transaction, constants.genesis->account (), { 1, constants.genesis->hash () });
} }
bool is_using_rocksdb (std::filesystem::path const & data_path, boost::program_options::variables_map const & vm, std::error_code & ec) bool is_using_rocksdb (std::filesystem::path const & data_path, boost::program_options::variables_map const & vm, std::error_code & ec)

2
nano/node/confirmation_height_bounded.cpp
View file

@ -104,7 +104,7 @@ void nano::confirmation_height_bounded::process (std::shared_ptr<nano::block> or
release_assert (block); release_assert (block);
} }
} }
auto account = ledger.account (*block); auto account = block->account ();
// Checks if we have encountered this account before but not commited changes yet, if so then update the cached confirmation height // Checks if we have encountered this account before but not commited changes yet, if so then update the cached confirmation height
nano::confirmation_height_info confirmation_height_info; nano::confirmation_height_info confirmation_height_info;

2
nano/node/confirmation_height_unbounded.cpp
View file

@ -79,7 +79,7 @@ void nano::confirmation_height_unbounded::process (std::shared_ptr<nano::block>
} }
release_assert (block); release_assert (block);
auto account = ledger.account (*block); auto account = block->account ();
auto block_height = block->sideband ().height; auto block_height = block->sideband ().height;
uint64_t confirmation_height = 0; uint64_t confirmation_height = 0;

4
nano/node/ipc/flatbuffers_util.cpp
View file

@ -6,7 +6,7 @@
std::unique_ptr<nanoapi::BlockStateT> nano::ipc::flatbuffers_builder::from (nano::state_block const & block_a, nano::amount const & amount_a, bool is_state_send_a, bool is_state_epoch_a) std::unique_ptr<nanoapi::BlockStateT> nano::ipc::flatbuffers_builder::from (nano::state_block const & block_a, nano::amount const & amount_a, bool is_state_send_a, bool is_state_epoch_a)
{ {
auto block (std::make_unique<nanoapi::BlockStateT> ()); auto block (std::make_unique<nanoapi::BlockStateT> ());
block->account = block_a.account ().value ().to_account (); block->account = block_a.account ().to_account ();
block->hash = block_a.hash ().to_string (); block->hash = block_a.hash ().to_string ();
block->previous = block_a.previous ().to_string (); block->previous = block_a.previous ().to_string ();
block->representative = block_a.representative ().to_account (); block->representative = block_a.representative ().to_account ();
@ -63,7 +63,7 @@ std::unique_ptr<nanoapi::BlockOpenT> nano::ipc::flatbuffers_builder::from (nano:
auto block (std::make_unique<nanoapi::BlockOpenT> ()); auto block (std::make_unique<nanoapi::BlockOpenT> ());
block->hash = block_a.hash ().to_string (); block->hash = block_a.hash ().to_string ();
block->source = block_a.source ().to_string (); block->source = block_a.source ().to_string ();
block->account = block_a.account ().value ().to_account (); block->account = block_a.account ().to_account ();
block->representative = block_a.representative ().to_account (); block->representative = block_a.representative ().to_account ();
block_a.signature.encode_hex (block->signature); block_a.signature.encode_hex (block->signature);
block->work = nano::to_string_hex (block_a.work); block->work = nano::to_string_hex (block_a.work);

18
nano/node/json_handler.cpp
View file

@ -415,7 +415,8 @@ uint64_t nano::json_handler::difficulty_ledger (nano::block const & block_a)
if (!link.is_zero () && !details.is_send) if (!link.is_zero () && !details.is_send)
{ {
auto block_link = node.ledger.block (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 ().value (), link.as_block_hash ()))) auto account = block_a.account_field ().value (); // Link is non-zero therefore it's a state block and has an account field;
if (block_link != nullptr && node.store.pending.exists (transaction, nano::pending_key (account, link.as_block_hash ())))
{ {
details.epoch = std::max (details.epoch, block_link->sideband ().details.epoch); details.epoch = std::max (details.epoch, block_link->sideband ().details.epoch);
details.is_receive = true; details.is_receive = true;
@ -1131,7 +1132,7 @@ void nano::json_handler::active_difficulty ()
void nano::json_handler::available_supply () void nano::json_handler::available_supply ()
{ {
auto genesis_balance (node.balance (node.network_params.ledger.genesis->account ().value ())); // Cold storage genesis auto genesis_balance (node.balance (node.network_params.ledger.genesis->account ())); // Cold storage genesis
auto landing_balance (node.balance (nano::account ("059F68AAB29DE0D3A27443625C7EA9CDDB6517A8B76FE37727EF6A4D76832AD5"))); // Active unavailable account auto landing_balance (node.balance (nano::account ("059F68AAB29DE0D3A27443625C7EA9CDDB6517A8B76FE37727EF6A4D76832AD5"))); // Active unavailable account
auto faucet_balance (node.balance (nano::account ("8E319CE6F3025E5B2DF66DA7AB1467FE48F1679C13DD43BFDB29FA2E9FC40D3B"))); // Faucet account auto faucet_balance (node.balance (nano::account ("8E319CE6F3025E5B2DF66DA7AB1467FE48F1679C13DD43BFDB29FA2E9FC40D3B"))); // Faucet account
auto burned_balance ((node.balance_pending (nano::account{}, false)).second); // Burning 0 account auto burned_balance ((node.balance_pending (nano::account{}, false)).second); // Burning 0 account
@ -1149,7 +1150,7 @@ void nano::json_handler::block_info ()
auto block = node.ledger.block (transaction, hash); auto block = node.ledger.block (transaction, hash);
if (block != nullptr) if (block != nullptr)
{ {
auto account = node.ledger.account (*block); auto account = block->account ();
response_l.put ("block_account", account.to_account ()); response_l.put ("block_account", account.to_account ());
auto amount = node.ledger.amount (transaction, hash); auto amount = node.ledger.amount (transaction, hash);
if (amount) if (amount)
@ -1214,7 +1215,7 @@ void nano::json_handler::block_confirm ()
nano::election_status status{ block_l, 0, 0, std::chrono::duration_cast<std::chrono::milliseconds> (std::chrono::system_clock::now ().time_since_epoch ()), std::chrono::duration_values<std::chrono::milliseconds>::zero (), 0, 1, 0, nano::election_status_type::active_confirmation_height }; nano::election_status status{ block_l, 0, 0, std::chrono::duration_cast<std::chrono::milliseconds> (std::chrono::system_clock::now ().time_since_epoch ()), std::chrono::duration_values<std::chrono::milliseconds>::zero (), 0, 1, 0, nano::election_status_type::active_confirmation_height };
node.active.recently_cemented.put (status); node.active.recently_cemented.put (status);
// Trigger callback for confirmed block // Trigger callback for confirmed block
auto account = node.ledger.account (*block_l); auto account = block_l->account ();
auto amount = node.ledger.amount (transaction, hash); auto amount = node.ledger.amount (transaction, hash);
bool is_state_send (false); bool is_state_send (false);
bool is_state_epoch (false); bool is_state_epoch (false);
@ -1306,7 +1307,7 @@ void nano::json_handler::blocks_info ()
if (block != nullptr) if (block != nullptr)
{ {
boost::property_tree::ptree entry; boost::property_tree::ptree entry;
auto account = node.ledger.account (*block); auto account = block->account ();
entry.put ("block_account", account.to_account ()); entry.put ("block_account", account.to_account ());
auto amount = node.ledger.amount (transaction, hash); auto amount = node.ledger.amount (transaction, hash);
if (amount) if (amount)
@ -1386,8 +1387,7 @@ void nano::json_handler::blocks_info ()
auto block_a = node.ledger.block (transaction, source_hash); auto block_a = node.ledger.block (transaction, source_hash);
if (block_a != nullptr) if (block_a != nullptr)
{ {
auto source_account (node.ledger.account (*block_a)); entry.put ("source_account", block_a->account ().to_account ());
entry.put ("source_account", source_account.to_account ());
} }
else else
{ {
@ -1433,7 +1433,7 @@ void nano::json_handler::block_account ()
auto block = node.ledger.block (transaction, hash); auto block = node.ledger.block (transaction, hash);
if (block) if (block)
{ {
response_l.put ("account", node.ledger.account (*block).to_account ()); response_l.put ("account", block->account ().to_account ());
} }
else else
{ {
@ -2454,7 +2454,7 @@ public:
} }
else else
{ {
tree.put ("account", handler.node.ledger.constants.genesis->account ().value ().to_account ()); tree.put ("account", handler.node.ledger.constants.genesis->account ().to_account ());
tree.put ("amount", nano::dev::constants.genesis_amount.convert_to<std::string> ()); tree.put ("amount", nano::dev::constants.genesis_amount.convert_to<std::string> ());
} }
} }

4
nano/node/node.cpp
View file

@ -1080,7 +1080,7 @@ bool nano::node::work_generation_enabled (std::vector<std::pair<std::string, uin
std::optional<uint64_t> nano::node::work_generate_blocking (nano::block & block_a, uint64_t difficulty_a) std::optional<uint64_t> nano::node::work_generate_blocking (nano::block & block_a, uint64_t difficulty_a)
{ {
auto opt_work_l (work_generate_blocking (block_a.work_version (), block_a.root (), difficulty_a, block_a.account ())); auto opt_work_l (work_generate_blocking (block_a.work_version (), block_a.root (), difficulty_a, block_a.account_field ()));
if (opt_work_l.has_value ()) if (opt_work_l.has_value ())
{ {
block_a.block_work_set (opt_work_l.value ()); block_a.block_work_set (opt_work_l.value ());
@ -1226,7 +1226,7 @@ void nano::node::receive_confirmed (store::transaction const & block_transaction
void nano::node::process_confirmed_data (store::transaction const & transaction_a, std::shared_ptr<nano::block> const & block_a, nano::block_hash const & hash_a, nano::account & account_a, nano::uint128_t & amount_a, bool & is_state_send_a, bool & is_state_epoch_a, nano::account & pending_account_a) void nano::node::process_confirmed_data (store::transaction const & transaction_a, std::shared_ptr<nano::block> const & block_a, nano::block_hash const & hash_a, nano::account & account_a, nano::uint128_t & amount_a, bool & is_state_send_a, bool & is_state_epoch_a, nano::account & pending_account_a)
{ {
// Faster account calculation // Faster account calculation
account_a = ledger.account (*block_a); account_a = block_a->account ();
// Faster amount calculation // Faster amount calculation
auto previous (block_a->previous ()); auto previous (block_a->previous ());
auto previous_balance = ledger.balance (transaction_a, previous); auto previous_balance = ledger.balance (transaction_a, previous);

4
nano/node/nodeconfig.cpp
View file

@ -49,7 +49,7 @@ nano::node_config::node_config (const std::optional<uint16_t> & peering_port_a,
{ {
case nano::networks::nano_dev_network: case nano::networks::nano_dev_network:
enable_voting = true; enable_voting = true;
preconfigured_representatives.push_back (network_params.ledger.genesis->account ().value ()); preconfigured_representatives.push_back (network_params.ledger.genesis->account ());
break; break;
case nano::networks::nano_beta_network: case nano::networks::nano_beta_network:
{ {
@ -72,7 +72,7 @@ nano::node_config::node_config (const std::optional<uint16_t> & peering_port_a,
break; break;
case nano::networks::nano_test_network: case nano::networks::nano_test_network:
preconfigured_peers.push_back (default_test_peer_network); preconfigured_peers.push_back (default_test_peer_network);
preconfigured_representatives.push_back (network_params.ledger.genesis->account ().value ()); preconfigured_representatives.push_back (network_params.ledger.genesis->account ());
break; break;
default: default:
debug_assert (false); debug_assert (false);

2
nano/node/process_live_dispatcher.cpp
View file

@ -45,7 +45,7 @@ void nano::process_live_dispatcher::process_live (nano::block const & block, sto
// Start collecting quorum on block // Start collecting quorum on block
if (ledger.dependents_confirmed (transaction, block)) if (ledger.dependents_confirmed (transaction, block))
{ {
scheduler.activate (ledger.account (block), transaction); scheduler.activate (block.account (), transaction);
} }
if (websocket.server && websocket.server->any_subscriber (nano::websocket::topic::new_unconfirmed_block)) if (websocket.server && websocket.server->any_subscriber (nano::websocket::topic::new_unconfirmed_block))

4
nano/node/request_aggregator.cpp
View file

@ -229,7 +229,7 @@ std::pair<std::vector<std::shared_ptr<nano::block>>, std::vector<std::shared_ptr
if (block != nullptr) if (block != nullptr)
{ {
nano::confirmation_height_info confirmation_height_info; nano::confirmation_height_info confirmation_height_info;
ledger.store.confirmation_height.get (transaction, ledger.account (*block), confirmation_height_info); ledger.store.confirmation_height.get (transaction, block->account (), confirmation_height_info);
generate_final_vote = (confirmation_height_info.height >= block->sideband ().height); generate_final_vote = (confirmation_height_info.height >= block->sideband ().height);
} }
} }
@ -265,7 +265,7 @@ std::pair<std::vector<std::shared_ptr<nano::block>>, std::vector<std::shared_ptr
if (block != nullptr && generate_vote) if (block != nullptr && generate_vote)
{ {
nano::confirmation_height_info confirmation_height_info; nano::confirmation_height_info confirmation_height_info;
ledger.store.confirmation_height.get (transaction, ledger.account (*block), confirmation_height_info); ledger.store.confirmation_height.get (transaction, block->account (), confirmation_height_info);
generate_final_vote = (confirmation_height_info.height >= block->sideband ().height); generate_final_vote = (confirmation_height_info.height >= block->sideband ().height);
} }
} }

2
nano/qt/qt.cpp
View file

@ -566,7 +566,7 @@ public:
} }
else else
{ {
account = ledger.constants.genesis->account ().value (); account = ledger.constants.genesis->account ();
amount = nano::dev::constants.genesis_amount; amount = nano::dev::constants.genesis_amount;
} }
} }

4
nano/rpc_test/rpc.cpp
View file

@ -3314,7 +3314,7 @@ TEST (rpc, pending_exists)
ASSERT_TRUE (pending_exists ("1")); ASSERT_TRUE (pending_exists ("1"));
ASSERT_TRUE (pending_exists ("1")); ASSERT_TRUE (pending_exists ("1"));
reset_confirmation_height (node->store, block1->account ().value ()); reset_confirmation_height (node->store, block1->account ());
ASSERT_TRUE (pending_exists ("0")); ASSERT_TRUE (pending_exists ("0"));
request.put ("include_only_confirmed", "false"); request.put ("include_only_confirmed", "false");
ASSERT_TRUE (pending_exists ("1")); ASSERT_TRUE (pending_exists ("1"));
@ -3419,7 +3419,7 @@ TEST (rpc, wallet_receivable)
ASSERT_EQ (sources[block1->hash ()], nano::dev::genesis_key.pub); ASSERT_EQ (sources[block1->hash ()], nano::dev::genesis_key.pub);
ASSERT_TRUE (check_block_response_count (system, rpc_ctx, request, 1)); ASSERT_TRUE (check_block_response_count (system, rpc_ctx, request, 1));
reset_confirmation_height (system.nodes.front ()->store, block1->account ().value ()); reset_confirmation_height (system.nodes.front ()->store, block1->account ());
ASSERT_TRUE (check_block_response_count (system, rpc_ctx, request, 0)); ASSERT_TRUE (check_block_response_count (system, rpc_ctx, request, 0));
request.put ("include_only_confirmed", "false"); request.put ("include_only_confirmed", "false");
ASSERT_TRUE (check_block_response_count (system, rpc_ctx, request, 1)); ASSERT_TRUE (check_block_response_count (system, rpc_ctx, request, 1));

10
nano/secure/common.cpp
View file

@ -127,15 +127,15 @@ nano::ledger_constants::ledger_constants (nano::work_thresholds & work, nano::ne
: network_a == nano::networks::nano_test_network ? nano_test_final_votes_canary_height : network_a == nano::networks::nano_test_network ? nano_test_final_votes_canary_height
: nano_live_final_votes_canary_height) : nano_live_final_votes_canary_height)
{ {
nano_beta_genesis->sideband_set (nano::block_sideband (nano_beta_genesis->account ().value (), 0, std::numeric_limits<nano::uint128_t>::max (), 1, nano::seconds_since_epoch (), nano::epoch::epoch_0, false, false, false, nano::epoch::epoch_0)); nano_beta_genesis->sideband_set (nano::block_sideband (nano_beta_genesis->account_field ().value (), 0, std::numeric_limits<nano::uint128_t>::max (), 1, nano::seconds_since_epoch (), nano::epoch::epoch_0, false, false, false, nano::epoch::epoch_0));
nano_dev_genesis->sideband_set (nano::block_sideband (nano_dev_genesis->account ().value (), 0, std::numeric_limits<nano::uint128_t>::max (), 1, nano::seconds_since_epoch (), nano::epoch::epoch_0, false, false, false, nano::epoch::epoch_0)); nano_dev_genesis->sideband_set (nano::block_sideband (nano_dev_genesis->account_field ().value (), 0, std::numeric_limits<nano::uint128_t>::max (), 1, nano::seconds_since_epoch (), nano::epoch::epoch_0, false, false, false, nano::epoch::epoch_0));
nano_live_genesis->sideband_set (nano::block_sideband (nano_live_genesis->account ().value (), 0, std::numeric_limits<nano::uint128_t>::max (), 1, nano::seconds_since_epoch (), nano::epoch::epoch_0, false, false, false, nano::epoch::epoch_0)); nano_live_genesis->sideband_set (nano::block_sideband (nano_live_genesis->account_field ().value (), 0, std::numeric_limits<nano::uint128_t>::max (), 1, nano::seconds_since_epoch (), nano::epoch::epoch_0, false, false, false, nano::epoch::epoch_0));
nano_test_genesis->sideband_set (nano::block_sideband (nano_test_genesis->account ().value (), 0, std::numeric_limits<nano::uint128_t>::max (), 1, nano::seconds_since_epoch (), nano::epoch::epoch_0, false, false, false, nano::epoch::epoch_0)); nano_test_genesis->sideband_set (nano::block_sideband (nano_test_genesis->account_field ().value (), 0, std::numeric_limits<nano::uint128_t>::max (), 1, nano::seconds_since_epoch (), nano::epoch::epoch_0, false, false, false, nano::epoch::epoch_0));
nano::link epoch_link_v1; nano::link epoch_link_v1;
char const * epoch_message_v1 ("epoch v1 block"); char const * epoch_message_v1 ("epoch v1 block");
strncpy ((char *)epoch_link_v1.bytes.data (), epoch_message_v1, epoch_link_v1.bytes.size ()); strncpy ((char *)epoch_link_v1.bytes.data (), epoch_message_v1, epoch_link_v1.bytes.size ());
epochs.add (nano::epoch::epoch_1, genesis->account ().value (), epoch_link_v1); epochs.add (nano::epoch::epoch_1, genesis->account (), epoch_link_v1);
nano::link epoch_link_v2; nano::link epoch_link_v2;
nano::account nano_live_epoch_v2_signer; nano::account nano_live_epoch_v2_signer;

18
nano/secure/ledger.cpp
View file

@ -64,7 +64,7 @@ public:
{ {
auto hash (block_a.hash ()); auto hash (block_a.hash ());
auto amount = ledger.amount (transaction, hash).value (); auto amount = ledger.amount (transaction, hash).value ();
auto destination_account = ledger.account (block_a); auto destination_account = block_a.account ();
// Pending account entry can be incorrect if source block was pruned. But it's not affecting correct ledger processing // Pending account entry can be incorrect if source block was pruned. But it's not affecting correct ledger processing
auto source_account = ledger.account (transaction, block_a.hashables.source); auto source_account = ledger.account (transaction, block_a.hashables.source);
auto info = ledger.account_info (transaction, destination_account); auto info = ledger.account_info (transaction, destination_account);
@ -83,7 +83,7 @@ public:
{ {
auto hash (block_a.hash ()); auto hash (block_a.hash ());
auto amount = ledger.amount (transaction, hash).value (); auto amount = ledger.amount (transaction, hash).value ();
auto destination_account = ledger.account (block_a); auto destination_account = block_a.account ();
auto source_account = ledger.account (transaction, block_a.hashables.source); auto source_account = ledger.account (transaction, block_a.hashables.source);
ledger.cache.rep_weights.representation_add (block_a.representative (), 0 - amount); ledger.cache.rep_weights.representation_add (block_a.representative (), 0 - amount);
nano::account_info new_info; nano::account_info new_info;
@ -97,7 +97,7 @@ public:
{ {
auto hash (block_a.hash ()); auto hash (block_a.hash ());
auto rep_block (ledger.representative (transaction, block_a.hashables.previous)); auto rep_block (ledger.representative (transaction, block_a.hashables.previous));
auto account = ledger.account (block_a); auto account = block_a.account ();
auto info = ledger.account_info (transaction, account); auto info = ledger.account_info (transaction, account);
debug_assert (info); debug_assert (info);
auto balance = ledger.balance (transaction, block_a.hashables.previous).value (); auto balance = ledger.balance (transaction, block_a.hashables.previous).value ();
@ -1129,12 +1129,6 @@ bool nano::ledger::rollback (store::write_transaction const & transaction_a, nan
return rollback (transaction_a, block_a, rollback_list); return rollback (transaction_a, block_a, rollback_list);
} }
nano::account nano::ledger::account (nano::block const & block)
{
debug_assert (block.has_sideband ());
return block.account ().value_or (block.sideband ().account);
}
std::optional<nano::account> nano::ledger::account (store::transaction const & transaction, nano::block_hash const & hash) const std::optional<nano::account> nano::ledger::account (store::transaction const & transaction, nano::block_hash const & hash) const
{ {
auto block_l = block (transaction, hash); auto block_l = block (transaction, hash);
@ -1142,7 +1136,7 @@ std::optional<nano::account> nano::ledger::account (store::transaction const & t
{ {
return std::nullopt; return std::nullopt;
} }
return account (*block_l); return block_l->account ();
} }
std::optional<nano::account_info> nano::ledger::account_info (store::transaction const & transaction, nano::account const & account) const std::optional<nano::account_info> nano::ledger::account_info (store::transaction const & transaction, nano::account const & account) const
@ -1425,7 +1419,7 @@ bool nano::ledger::block_confirmed (store::transaction const & transaction_a, na
if (block_l) if (block_l)
{ {
nano::confirmation_height_info confirmation_height_info; nano::confirmation_height_info confirmation_height_info;
store.confirmation_height.get (transaction_a, account (*block_l), confirmation_height_info); store.confirmation_height.get (transaction_a, block_l->account (), confirmation_height_info);
auto confirmed (confirmation_height_info.height >= block_l->sideband ().height); auto confirmed (confirmation_height_info.height >= block_l->sideband ().height);
return confirmed; return confirmed;
} }
@ -1610,7 +1604,7 @@ bool nano::ledger::migrate_lmdb_to_rocksdb (std::filesystem::path const & data_p
auto random_block (store.block.random (lmdb_transaction)); auto random_block (store.block.random (lmdb_transaction));
error |= rocksdb_store->block.get (rocksdb_transaction, random_block->hash ()) == nullptr; error |= rocksdb_store->block.get (rocksdb_transaction, random_block->hash ()) == nullptr;
auto account = this->account (*random_block); auto account = random_block->account ();
nano::account_info account_info; nano::account_info account_info;
error |= rocksdb_store->account.get (rocksdb_transaction, account, account_info); error |= rocksdb_store->account.get (rocksdb_transaction, account, account_info);

4
nano/secure/ledger.hpp
View file

@ -30,10 +30,6 @@ class ledger final
{ {
public: public:
ledger (nano::store::component &, nano::stats &, nano::ledger_constants & constants, nano::generate_cache const & = nano::generate_cache ()); ledger (nano::store::component &, nano::stats &, nano::ledger_constants & constants, nano::generate_cache const & = nano::generate_cache ());
/**
* Return account containing hash, expects that block hash exists in ledger
*/
static nano::account account (nano::block const & block);
/** /**
* Returns the account for a given hash * Returns the account for a given hash
* Returns std::nullopt if the block doesn't exist or has been pruned * Returns std::nullopt if the block doesn't exist or has been pruned

8
nano/store/component.cpp
View file

@ -31,11 +31,11 @@ void nano::store::component::initialize (store::write_transaction const & transa
auto hash_l (constants.genesis->hash ()); auto hash_l (constants.genesis->hash ());
block.put (transaction_a, hash_l, *constants.genesis); block.put (transaction_a, hash_l, *constants.genesis);
++ledger_cache_a.block_count; ++ledger_cache_a.block_count;
confirmation_height.put (transaction_a, constants.genesis->account ().value (), nano::confirmation_height_info{ 1, constants.genesis->hash () }); confirmation_height.put (transaction_a, constants.genesis->account (), nano::confirmation_height_info{ 1, constants.genesis->hash () });
++ledger_cache_a.cemented_count; ++ledger_cache_a.cemented_count;
ledger_cache_a.final_votes_confirmation_canary = (constants.final_votes_canary_account == constants.genesis->account () && 1 >= constants.final_votes_canary_height); ledger_cache_a.final_votes_confirmation_canary = (constants.final_votes_canary_account == constants.genesis->account () && 1 >= constants.final_votes_canary_height);
account.put (transaction_a, constants.genesis->account ().value (), { hash_l, constants.genesis->account ().value (), constants.genesis->hash (), std::numeric_limits<nano::uint128_t>::max (), nano::seconds_since_epoch (), 1, nano::epoch::epoch_0 }); account.put (transaction_a, constants.genesis->account (), { hash_l, constants.genesis->account (), constants.genesis->hash (), std::numeric_limits<nano::uint128_t>::max (), nano::seconds_since_epoch (), 1, nano::epoch::epoch_0 });
++ledger_cache_a.account_count; ++ledger_cache_a.account_count;
ledger_cache_a.rep_weights.representation_put (constants.genesis->account ().value (), std::numeric_limits<nano::uint128_t>::max ()); ledger_cache_a.rep_weights.representation_put (constants.genesis->account (), std::numeric_limits<nano::uint128_t>::max ());
frontier.put (transaction_a, hash_l, constants.genesis->account ().value ()); frontier.put (transaction_a, hash_l, constants.genesis->account ());
} }