From a7cab75095c8c77c06f43d9a4646b6dd09e703cb Mon Sep 17 00:00:00 2001 From: Colin LeMahieu Date: Wed, 6 Mar 2024 17:14:00 +0000 Subject: [PATCH] ledger::account is moved to block::account and block::account which accesses the account field is renamed to block::account_field. --- nano/core_test/active_transactions.cpp | 4 ++-- nano/core_test/backlog.cpp | 2 +- nano/core_test/ledger.cpp | 12 +++++------ nano/lib/blocks.cpp | 23 ++++++++++++++++++--- nano/lib/blocks.hpp | 12 ++++++++--- nano/node/active_transactions.cpp | 2 +- nano/node/blockprocessor.cpp | 2 +- nano/node/bootstrap/bootstrap_bulk_pull.cpp | 4 ++-- nano/node/bootstrap_ascending/service.cpp | 6 +++--- nano/node/cli.cpp | 2 +- nano/node/confirmation_height_bounded.cpp | 2 +- nano/node/confirmation_height_unbounded.cpp | 2 +- nano/node/ipc/flatbuffers_util.cpp | 4 ++-- nano/node/json_handler.cpp | 18 ++++++++-------- nano/node/node.cpp | 4 ++-- nano/node/nodeconfig.cpp | 4 ++-- nano/node/process_live_dispatcher.cpp | 2 +- nano/node/request_aggregator.cpp | 4 ++-- nano/qt/qt.cpp | 2 +- nano/rpc_test/rpc.cpp | 4 ++-- nano/secure/common.cpp | 10 ++++----- nano/secure/ledger.cpp | 18 ++++++---------- nano/secure/ledger.hpp | 4 ---- nano/store/component.cpp | 8 +++---- 24 files changed, 84 insertions(+), 71 deletions(-) diff --git a/nano/core_test/active_transactions.cpp b/nano/core_test/active_transactions.cpp index 85fc7a1ef..2b1bc50d0 100644 --- a/nano/core_test/active_transactions.cpp +++ b/nano/core_test/active_transactions.cpp @@ -1534,7 +1534,7 @@ TEST (active_transactions, allow_limited_overflow) // Insert the first part of the blocks into normal election scheduler 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 @@ -1596,7 +1596,7 @@ TEST (active_transactions, allow_limited_overflow_adapt) // Insert the first part of the blocks into normal election scheduler 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 diff --git a/nano/core_test/backlog.cpp b/nano/core_test/backlog.cpp index 70ccb6b28..26d5680a8 100644 --- a/nano/core_test/backlog.cpp +++ b/nano/core_test/backlog.cpp @@ -33,7 +33,7 @@ TEST (backlog, population) auto all_activated = [&] () { nano::lock_guard lock{ mutex }; 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 ()); diff --git a/nano/core_test/ledger.cpp b/nano/core_test/ledger.cpp index 2e6115132..be50f1eec 100644 --- a/nano/core_test/ledger.cpp +++ b/nano/core_test/ledger.cpp @@ -113,7 +113,7 @@ TEST (ledger, process_send) 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::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 (nano::dev::constants.genesis_amount - 50, ledger.account_receivable (transaction, key2.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 (nano::dev::constants.genesis_amount - 50, ledger.amount (transaction, hash2)); 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 (key2.pub, store.frontier.get (transaction, hash2)); 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 ()); auto return1 = ledger.process (transaction, open); 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 (nano::dev::constants.genesis_amount - 50, open->sideband ().balance.number ()); ASSERT_EQ (1, open->sideband ().height); @@ -259,7 +259,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::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 (25, ledger.account_balance (transaction, nano::dev::genesis_key.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_EQ (nano::dev::genesis_key.pub, store.frontier.get (transaction, block->hash ())); 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 (nano::dev::constants.genesis_amount, ledger.weight (key2.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_FALSE (node1.ledger.block_or_pruned_exists (epoch_open->hash ())); // 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[0].block->full_hash (), epoch_open->full_hash ()); // New block to process epoch open diff --git a/nano/lib/blocks.cpp b/nano/lib/blocks.cpp index 253ecaa7e..c2f5cbc2f 100644 --- a/nano/lib/blocks.cpp +++ b/nano/lib/blocks.cpp @@ -185,7 +185,24 @@ nano::link const & nano::block::link () const return link; } -std::optional 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::block::account_field () const { return std::nullopt; } @@ -642,7 +659,7 @@ nano::block_hash const & nano::open_block::previous () const return result; } -std::optional nano::open_block::account () const +std::optional nano::open_block::account_field () const { return hashables.account; } @@ -1212,7 +1229,7 @@ nano::block_hash const & nano::state_block::previous () const return hashables.previous; } -std::optional nano::state_block::account () const +std::optional nano::state_block::account_field () const { return hashables.account; } diff --git a/nano/lib/blocks.hpp b/nano/lib/blocks.hpp index 18514a907..f4a47650e 100644 --- a/nano/lib/blocks.hpp +++ b/nano/lib/blocks.hpp @@ -64,8 +64,10 @@ public: void refresh (); 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 - virtual std::optional account () const; + virtual std::optional account_field () const; protected: mutable nano::block_hash cached_hash{ 0 }; @@ -213,7 +215,6 @@ public: uint64_t block_work () const override; void block_work_set (uint64_t) override; nano::block_hash const & previous () const override; - std::optional account () const override; nano::block_hash const & source () const override; nano::root const & root () const override; nano::account const & representative () const override; @@ -235,6 +236,9 @@ public: uint64_t work; static std::size_t constexpr size = nano::open_hashables::size + sizeof (signature) + sizeof (work); +public: // Open block fields + std::optional account_field () const override; + public: // Logging void operator() (nano::object_stream &) const override; }; @@ -328,7 +332,6 @@ public: uint64_t block_work () const override; void block_work_set (uint64_t) override; nano::block_hash const & previous () const override; - std::optional account () const override; nano::root const & root () const override; nano::link const & link () const override; nano::account const & representative () const override; @@ -351,6 +354,9 @@ public: uint64_t work; static std::size_t constexpr size = nano::state_hashables::size + sizeof (signature) + sizeof (work); +public: // State block fields + std::optional account_field () const override; + public: // Logging void operator() (nano::object_stream &) const override; }; diff --git a/nano/node/active_transactions.cpp b/nano/node/active_transactions.cpp index b5c4a83df..0b39a6c67 100644 --- a/nano/node/active_transactions.cpp +++ b/nano/node/active_transactions.cpp @@ -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 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_account = account == node.network_params.ledger.final_votes_canary_account; diff --git a/nano/node/blockprocessor.cpp b/nano/node/blockprocessor.cpp index 54297c733..ecbd66985 100644 --- a/nano/node/blockprocessor.cpp +++ b/nano/node/blockprocessor.cpp @@ -362,7 +362,7 @@ nano::block_status nano::block_processor::process_one (store::write_transaction } 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); break; } diff --git a/nano/node/bootstrap/bootstrap_bulk_pull.cpp b/nano/node/bootstrap/bootstrap_bulk_pull.cpp index 00e9a8ece..d4b4e1321 100644 --- a/nano/node/bootstrap/bootstrap_bulk_pull.cpp +++ b/nano/node/bootstrap/bootstrap_bulk_pull.cpp @@ -176,7 +176,7 @@ void nano::bulk_pull_client::received_block (boost::system::error_code ec, std:: // Is block expected? 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 (...) - 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) { 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) { - known_account = block->account ().value_or (0); + known_account = block->account_field ().value_or (0); } if (connection->block_count++ == 0) { diff --git a/nano/node/bootstrap_ascending/service.cpp b/nano/node/bootstrap_ascending/service.cpp index aad14eb00..33746a1d6 100644 --- a/nano/node/bootstrap_ascending/service.cpp +++ b/nano/node/bootstrap_ascending/service.cpp @@ -133,7 +133,7 @@ void nano::bootstrap_ascending::service::inspect (store::transaction const & tx, { 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); // 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; 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 (); // 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: { // 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 return verify_result::invalid; diff --git a/nano/node/cli.cpp b/nano/node/cli.cpp index 2f3372e40..984f1656f 100644 --- a/nano/node/cli.cpp +++ b/nano/node/cli.cpp @@ -1324,7 +1324,7 @@ void reset_confirmation_heights (nano::store::write_transaction const & transact store.confirmation_height.clear (transaction); // 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) diff --git a/nano/node/confirmation_height_bounded.cpp b/nano/node/confirmation_height_bounded.cpp index 4d221a3f5..68faaf07a 100644 --- a/nano/node/confirmation_height_bounded.cpp +++ b/nano/node/confirmation_height_bounded.cpp @@ -104,7 +104,7 @@ void nano::confirmation_height_bounded::process (std::shared_ptr or 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 nano::confirmation_height_info confirmation_height_info; diff --git a/nano/node/confirmation_height_unbounded.cpp b/nano/node/confirmation_height_unbounded.cpp index cae1ec5cf..b93fc6354 100644 --- a/nano/node/confirmation_height_unbounded.cpp +++ b/nano/node/confirmation_height_unbounded.cpp @@ -79,7 +79,7 @@ void nano::confirmation_height_unbounded::process (std::shared_ptr } release_assert (block); - auto account = ledger.account (*block); + auto account = block->account (); auto block_height = block->sideband ().height; uint64_t confirmation_height = 0; diff --git a/nano/node/ipc/flatbuffers_util.cpp b/nano/node/ipc/flatbuffers_util.cpp index eb90c4731..8cf1fe5e4 100644 --- a/nano/node/ipc/flatbuffers_util.cpp +++ b/nano/node/ipc/flatbuffers_util.cpp @@ -6,7 +6,7 @@ std::unique_ptr 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 ()); - block->account = block_a.account ().value ().to_account (); + block->account = block_a.account ().to_account (); block->hash = block_a.hash ().to_string (); block->previous = block_a.previous ().to_string (); block->representative = block_a.representative ().to_account (); @@ -63,7 +63,7 @@ std::unique_ptr nano::ipc::flatbuffers_builder::from (nano: auto block (std::make_unique ()); block->hash = block_a.hash ().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_a.signature.encode_hex (block->signature); block->work = nano::to_string_hex (block_a.work); diff --git a/nano/node/json_handler.cpp b/nano/node/json_handler.cpp index f6afe32f7..5b271232b 100644 --- a/nano/node/json_handler.cpp +++ b/nano/node/json_handler.cpp @@ -415,7 +415,8 @@ uint64_t nano::json_handler::difficulty_ledger (nano::block const & block_a) if (!link.is_zero () && !details.is_send) { 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.is_receive = true; @@ -1131,7 +1132,7 @@ void nano::json_handler::active_difficulty () 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 faucet_balance (node.balance (nano::account ("8E319CE6F3025E5B2DF66DA7AB1467FE48F1679C13DD43BFDB29FA2E9FC40D3B"))); // Faucet 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); if (block != nullptr) { - auto account = node.ledger.account (*block); + auto account = block->account (); response_l.put ("block_account", account.to_account ()); auto amount = node.ledger.amount (transaction, hash); 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::system_clock::now ().time_since_epoch ()), std::chrono::duration_values::zero (), 0, 1, 0, nano::election_status_type::active_confirmation_height }; node.active.recently_cemented.put (status); // Trigger callback for confirmed block - auto account = node.ledger.account (*block_l); + auto account = block_l->account (); auto amount = node.ledger.amount (transaction, hash); bool is_state_send (false); bool is_state_epoch (false); @@ -1306,7 +1307,7 @@ void nano::json_handler::blocks_info () if (block != nullptr) { boost::property_tree::ptree entry; - auto account = node.ledger.account (*block); + auto account = block->account (); entry.put ("block_account", account.to_account ()); auto amount = node.ledger.amount (transaction, hash); if (amount) @@ -1386,8 +1387,7 @@ void nano::json_handler::blocks_info () auto block_a = node.ledger.block (transaction, source_hash); if (block_a != nullptr) { - auto source_account (node.ledger.account (*block_a)); - entry.put ("source_account", source_account.to_account ()); + entry.put ("source_account", block_a->account ().to_account ()); } else { @@ -1433,7 +1433,7 @@ void nano::json_handler::block_account () auto block = node.ledger.block (transaction, hash); if (block) { - response_l.put ("account", node.ledger.account (*block).to_account ()); + response_l.put ("account", block->account ().to_account ()); } else { @@ -2454,7 +2454,7 @@ public: } 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 ()); } } diff --git a/nano/node/node.cpp b/nano/node/node.cpp index bcf845bf9..61a1c7fe1 100644 --- a/nano/node/node.cpp +++ b/nano/node/node.cpp @@ -1080,7 +1080,7 @@ bool nano::node::work_generation_enabled (std::vector 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 ()) { 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 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 - account_a = ledger.account (*block_a); + account_a = block_a->account (); // Faster amount calculation auto previous (block_a->previous ()); auto previous_balance = ledger.balance (transaction_a, previous); diff --git a/nano/node/nodeconfig.cpp b/nano/node/nodeconfig.cpp index edd039d82..beb93cb4f 100644 --- a/nano/node/nodeconfig.cpp +++ b/nano/node/nodeconfig.cpp @@ -49,7 +49,7 @@ nano::node_config::node_config (const std::optional & peering_port_a, { case nano::networks::nano_dev_network: enable_voting = true; - preconfigured_representatives.push_back (network_params.ledger.genesis->account ().value ()); + preconfigured_representatives.push_back (network_params.ledger.genesis->account ()); break; case nano::networks::nano_beta_network: { @@ -72,7 +72,7 @@ nano::node_config::node_config (const std::optional & peering_port_a, break; case nano::networks::nano_test_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; default: debug_assert (false); diff --git a/nano/node/process_live_dispatcher.cpp b/nano/node/process_live_dispatcher.cpp index 4fd77e3c3..f0d457dbe 100644 --- a/nano/node/process_live_dispatcher.cpp +++ b/nano/node/process_live_dispatcher.cpp @@ -45,7 +45,7 @@ void nano::process_live_dispatcher::process_live (nano::block const & block, sto // Start collecting quorum on 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)) diff --git a/nano/node/request_aggregator.cpp b/nano/node/request_aggregator.cpp index 43e417219..0e61195e8 100644 --- a/nano/node/request_aggregator.cpp +++ b/nano/node/request_aggregator.cpp @@ -229,7 +229,7 @@ std::pair>, std::vectoraccount (), confirmation_height_info); generate_final_vote = (confirmation_height_info.height >= block->sideband ().height); } } @@ -265,7 +265,7 @@ std::pair>, std::vectoraccount (), confirmation_height_info); generate_final_vote = (confirmation_height_info.height >= block->sideband ().height); } } diff --git a/nano/qt/qt.cpp b/nano/qt/qt.cpp index 4942294f3..640080b55 100644 --- a/nano/qt/qt.cpp +++ b/nano/qt/qt.cpp @@ -566,7 +566,7 @@ public: } else { - account = ledger.constants.genesis->account ().value (); + account = ledger.constants.genesis->account (); amount = nano::dev::constants.genesis_amount; } } diff --git a/nano/rpc_test/rpc.cpp b/nano/rpc_test/rpc.cpp index 9045fc413..16fd73146 100644 --- a/nano/rpc_test/rpc.cpp +++ b/nano/rpc_test/rpc.cpp @@ -3314,7 +3314,7 @@ TEST (rpc, pending_exists) 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")); request.put ("include_only_confirmed", "false"); ASSERT_TRUE (pending_exists ("1")); @@ -3419,7 +3419,7 @@ TEST (rpc, wallet_receivable) ASSERT_EQ (sources[block1->hash ()], nano::dev::genesis_key.pub); 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)); request.put ("include_only_confirmed", "false"); ASSERT_TRUE (check_block_response_count (system, rpc_ctx, request, 1)); diff --git a/nano/secure/common.cpp b/nano/secure/common.cpp index 0812ee4ea..6b91dd676 100644 --- a/nano/secure/common.cpp +++ b/nano/secure/common.cpp @@ -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 : nano_live_final_votes_canary_height) { - nano_beta_genesis->sideband_set (nano::block_sideband (nano_beta_genesis->account ().value (), 0, std::numeric_limits::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::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::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::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::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::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::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::max (), 1, nano::seconds_since_epoch (), nano::epoch::epoch_0, false, false, false, nano::epoch::epoch_0)); nano::link epoch_link_v1; char const * epoch_message_v1 ("epoch v1 block"); 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::account nano_live_epoch_v2_signer; diff --git a/nano/secure/ledger.cpp b/nano/secure/ledger.cpp index be4afa8d2..7477722ed 100644 --- a/nano/secure/ledger.cpp +++ b/nano/secure/ledger.cpp @@ -64,7 +64,7 @@ public: { auto hash (block_a.hash ()); 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 auto source_account = ledger.account (transaction, block_a.hashables.source); auto info = ledger.account_info (transaction, destination_account); @@ -83,7 +83,7 @@ public: { auto hash (block_a.hash ()); 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); ledger.cache.rep_weights.representation_add (block_a.representative (), 0 - amount); nano::account_info new_info; @@ -97,7 +97,7 @@ public: { auto hash (block_a.hash ()); 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); debug_assert (info); 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); } -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::ledger::account (store::transaction const & transaction, nano::block_hash const & hash) const { auto block_l = block (transaction, hash); @@ -1142,7 +1136,7 @@ std::optional nano::ledger::account (store::transaction const & t { return std::nullopt; } - return account (*block_l); + return block_l->account (); } std::optional 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) { 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); 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)); 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; error |= rocksdb_store->account.get (rocksdb_transaction, account, account_info); diff --git a/nano/secure/ledger.hpp b/nano/secure/ledger.hpp index 6b3eddd69..bfc1681dc 100644 --- a/nano/secure/ledger.hpp +++ b/nano/secure/ledger.hpp @@ -30,10 +30,6 @@ class ledger final { public: 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 std::nullopt if the block doesn't exist or has been pruned diff --git a/nano/store/component.cpp b/nano/store/component.cpp index c95c16a19..67826f634 100644 --- a/nano/store/component.cpp +++ b/nano/store/component.cpp @@ -31,11 +31,11 @@ void nano::store::component::initialize (store::write_transaction const & transa auto hash_l (constants.genesis->hash ()); block.put (transaction_a, hash_l, *constants.genesis); ++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.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::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::max (), nano::seconds_since_epoch (), 1, nano::epoch::epoch_0 }); ++ledger_cache_a.account_count; - ledger_cache_a.rep_weights.representation_put (constants.genesis->account ().value (), std::numeric_limits::max ()); - frontier.put (transaction_a, hash_l, constants.genesis->account ().value ()); + ledger_cache_a.rep_weights.representation_put (constants.genesis->account (), std::numeric_limits::max ()); + frontier.put (transaction_a, hash_l, constants.genesis->account ()); }