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

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
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

2
nano/core_test/backlog.cpp
View file

@ -33,7 +33,7 @@ TEST (backlog, population)
auto all_activated = [&] () {
nano::lock_guard<nano::mutex> 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 ());

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_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

23
nano/lib/blocks.cpp
View file

@ -185,7 +185,24 @@ nano::link const & nano::block::link () const
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;
}
@ -642,7 +659,7 @@ nano::block_hash const & nano::open_block::previous () const
return result;
}
std::optional<nano::account> nano::open_block::account () const
std::optional<nano::account> 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::account> nano::state_block::account () const
std::optional<nano::account> nano::state_block::account_field () const
{
return hashables.account;
}

12
nano/lib/blocks.hpp
View file

@ -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<nano::account> account () const;
virtual std::optional<nano::account> 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<nano::account> 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<nano::account> 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<nano::account> 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<nano::account> account_field () const override;
public: // Logging
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)
{
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;

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:
{
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;
}

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?
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)
{

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:
{
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;

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);
// 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)

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);
}
}
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;

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);
auto account = ledger.account (*block);
auto account = block->account ();
auto block_height = block->sideband ().height;
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)
{
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->previous = block_a.previous ().to_string ();
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> ());
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);

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)
{
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::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);
// 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<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)
{
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<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
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);

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:
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<uint16_t> & 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);

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
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))

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)
{
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);
}
}
@ -265,7 +265,7 @@ std::pair<std::vector<std::shared_ptr<nano::block>>, std::vector<std::shared_ptr
if (block != nullptr && generate_vote)
{
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);
}
}

2
nano/qt/qt.cpp
View file

@ -566,7 +566,7 @@ public:
}
else
{
account = ledger.constants.genesis->account ().value ();
account = ledger.constants.genesis->account ();
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"));
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));

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
: 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_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_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_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_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_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_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_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;
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;

18
nano/secure/ledger.cpp
View file

@ -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::account> 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::account> nano::ledger::account (store::transaction const & t
{
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
@ -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);

4
nano/secure/ledger.hpp
View file

@ -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

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 ());
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<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.rep_weights.representation_put (constants.genesis->account ().value (), std::numeric_limits<nano::uint128_t>::max ());
frontier.put (transaction_a, hash_l, constants.genesis->account ().value ());
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 ());
}