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

Require explicit conversion from root/link to block hash or account (#2761)

Browse source
This commit is contained in:
Wesley Shillingford 2020-09-10 11:44:22 +01:00 • committed by GitHub
commit 47c2740add
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
18 changed files with 68 additions and 67 deletions
Download patch file Download diff file Expand all files Collapse all files

2
nano/core_test/node.cpp
View file

@ -3046,7 +3046,7 @@ TEST (node, epoch_conflict_confirm)
.work (*system.work.generate (send->hash ()))
.build_shared ();
auto epoch_open = builder.make_block ()
.account (change->root ())
.account (change->root ().as_account ())
.previous (0)
.representative (0)
.balance (0)

4
nano/lib/numbers.cpp
View file

@ -830,12 +830,12 @@ std::string nano::hash_or_account::to_account () const
return account.to_account ();
}
nano::hash_or_account::operator nano::block_hash const & () const
nano::block_hash const & nano::hash_or_account::as_block_hash () const
{
return hash;
}
nano::hash_or_account::operator nano::account const & () const
nano::account const & nano::hash_or_account::as_account () const
{
return account;
}

5
nano/lib/numbers.hpp
View file

@ -147,8 +147,9 @@ public:
bool decode_account (std::string const &);
std::string to_account () const;
operator nano::block_hash const & () const;
operator nano::account const & () const;
nano::account const & as_account () const;
nano::block_hash const & as_block_hash () const;
operator nano::uint256_union const & () const;
bool operator== (nano::hash_or_account const &) const;

12
nano/nano_node/entry.cpp
View file

@ -959,7 +959,7 @@ int main (int argc, char * const * argv)
auto send = builder.state ()
.account (keys[j].pub)
.previous (frontiers[j])
.previous (frontiers[j].as_block_hash ())
.representative (keys[j].pub)
.balance (balances[j])
.link (keys[other].pub)
@ -974,10 +974,10 @@ int main (int argc, char * const * argv)
auto receive = builder.state ()
.account (keys[other].pub)
.previous (frontiers[other])
.previous (frontiers[other].as_block_hash ())
.representative (keys[other].pub)
.balance (balances[other])
.link (static_cast<nano::block_hash const &> (frontiers[j]))
.link (frontiers[j].as_block_hash ())
.sign (keys[other].prv, keys[other].pub)
.work (*work.generate (nano::work_version::work_1, frontiers[other], node->network_params.network.publish_thresholds.epoch_1))
.build ();
@ -1529,7 +1529,7 @@ int main (int argc, char * const * argv)
{
// State receive
block_details_error = !sideband.details.is_receive || sideband.details.is_send || sideband.details.is_epoch;
block_details_error |= !node->store.block_exists (transaction, block->link ());
block_details_error |= !node->store.block_exists (transaction, block->link ().as_block_hash ());
}
}
}
@ -1540,7 +1540,7 @@ int main (int argc, char * const * argv)
// Check link epoch version
if (sideband.details.is_receive)
{
if (sideband.source_epoch != node->store.block_version (transaction, block->link ()))
if (sideband.source_epoch != node->store.block_version (transaction, block->link ().as_block_hash ()))
{
print_error_message (boost::str (boost::format ("Incorrect source epoch for block %1%\n") % hash.to_string ()));
}
@ -1666,7 +1666,7 @@ int main (int argc, char * const * argv)
{
if (node->ledger.is_send (transaction, *state))
{
destination = state->hashables.link;
destination = state->hashables.link.as_account ();
}
}
else if (auto send = dynamic_cast<nano::send_block *> (block.get ()))

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

@ -435,20 +435,20 @@ void nano::bulk_pull_server::set_current_end ()
request->end.clear ();
}
if (connection->node->store.block_exists (transaction, request->start))
if (connection->node->store.block_exists (transaction, request->start.as_block_hash ()))
{
if (connection->node->config.logging.bulk_pull_logging ())
{
connection->node->logger.try_log (boost::str (boost::format ("Bulk pull request for block hash: %1%") % request->start.to_string ()));
}
current = request->start;
current = request->start.as_block_hash ();
include_start = true;
}
else
{
nano::account_info info;
auto no_address (connection->node->store.account_get (transaction, request->start, info));
auto no_address (connection->node->store.account_get (transaction, request->start.as_account (), info));
if (no_address)
{
if (connection->node->config.logging.bulk_pull_logging ())

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

@ -416,7 +416,7 @@ void nano::bootstrap_connections::requeue_pull (nano::pull_info const & pull_a,
else if (attempt_l->mode == nano::bootstrap_mode::lazy && (pull.retry_limit == std::numeric_limits<unsigned>::max () || pull.attempts <= pull.retry_limit + (pull.processed / node.network_params.bootstrap.lazy_max_pull_blocks)))
{
debug_assert (pull.account_or_head == pull.head);
if (!attempt_l->lazy_processed_or_exists (pull.account_or_head))
if (!attempt_l->lazy_processed_or_exists (pull.account_or_head.as_block_hash ()))
{
{
nano::lock_guard<std::mutex> lock (mutex);

24
nano/node/bootstrap/bootstrap_lazy.cpp
View file

@ -31,9 +31,9 @@ void nano::bootstrap_attempt_lazy::lazy_start (nano::hash_or_account const & has
nano::unique_lock<std::mutex> lock (mutex);
// Add start blocks, limit 1024 (4k with disabled legacy bootstrap)
size_t max_keys (node->flags.disable_legacy_bootstrap ? 4 * 1024 : 1024);
if (lazy_keys.size () < max_keys && lazy_keys.find (hash_or_account_a) == lazy_keys.end () && !lazy_blocks_processed (hash_or_account_a))
if (lazy_keys.size () < max_keys && lazy_keys.find (hash_or_account_a.as_block_hash ()) == lazy_keys.end () && !lazy_blocks_processed (hash_or_account_a.as_block_hash ()))
{
lazy_keys.insert (hash_or_account_a);
lazy_keys.insert (hash_or_account_a.as_block_hash ());
lazy_pulls.emplace_back (hash_or_account_a, confirmed ? std::numeric_limits<unsigned>::max () : node->network_params.bootstrap.lazy_retry_limit);
lock.unlock ();
condition.notify_all ();
@ -44,7 +44,7 @@ void nano::bootstrap_attempt_lazy::lazy_add (nano::hash_or_account const & hash_
{
// Add only unknown blocks
debug_assert (!mutex.try_lock ());
if (!lazy_blocks_processed (hash_or_account_a))
if (!lazy_blocks_processed (hash_or_account_a.as_block_hash ()))
{
lazy_pulls.emplace_back (hash_or_account_a, retry_limit);
}
@ -103,10 +103,10 @@ void nano::bootstrap_attempt_lazy::lazy_pull_flush (nano::unique_lock<std::mutex
auto pull_start (lazy_pulls.front ());
lazy_pulls.pop_front ();
// Recheck if block was already processed
if (!lazy_blocks_processed (pull_start.first) && !node->store.block_exists (transaction, pull_start.first))
if (!lazy_blocks_processed (pull_start.first.as_block_hash ()) && !node->store.block_exists (transaction, pull_start.first.as_block_hash ()))
{
lock_a.unlock ();
node->bootstrap_initiator.connections->add_pull (nano::pull_info (pull_start.first, pull_start.first, nano::block_hash (0), incremental_id, batch_count, pull_start.second));
node->bootstrap_initiator.connections->add_pull (nano::pull_info (pull_start.first, pull_start.first.as_block_hash (), nano::block_hash (0), incremental_id, batch_count, pull_start.second));
++pulling;
++count;
lock_a.lock ();
@ -300,7 +300,7 @@ void nano::bootstrap_attempt_lazy::lazy_block_state (std::shared_ptr<nano::block
nano::uint128_t balance (block_l->hashables.balance.number ());
auto const & link (block_l->hashables.link);
// If link is not epoch link or 0. And if block from link is unknown
if (!link.is_zero () && !node->ledger.is_epoch_link (link) && !lazy_blocks_processed (link) && !node->store.block_exists (transaction, link))
if (!link.is_zero () && !node->ledger.is_epoch_link (link) && !lazy_blocks_processed (link.as_block_hash ()) && !node->store.block_exists (transaction, link.as_block_hash ()))
{
auto const & previous (block_l->hashables.previous);
// If state block previous is 0 then source block required
@ -317,7 +317,7 @@ void nano::bootstrap_attempt_lazy::lazy_block_state (std::shared_ptr<nano::block
}
else
{
lazy_destinations_increment (link);
lazy_destinations_increment (link.as_account ());
}
}
// Search balance of already processed previous blocks
@ -332,7 +332,7 @@ void nano::bootstrap_attempt_lazy::lazy_block_state (std::shared_ptr<nano::block
}
else
{
lazy_destinations_increment (link);
lazy_destinations_increment (link.as_account ());
}
lazy_balances.erase (previous_balance);
}
@ -362,14 +362,14 @@ void nano::bootstrap_attempt_lazy::lazy_block_state_backlog_check (std::shared_p
}
else
{
lazy_destinations_increment (next_block.link);
lazy_destinations_increment (next_block.link.as_account ());
}
}
// Assumption for other legacy block types
else if (lazy_undefined_links.find (next_block.link) == lazy_undefined_links.end ())
else if (lazy_undefined_links.find (next_block.link.as_block_hash ()) == lazy_undefined_links.end ())
{
lazy_add (next_block.link, node->network_params.bootstrap.lazy_retry_limit); // Head is not confirmed. It can be account or hash or non-existing
lazy_undefined_links.insert (next_block.link);
lazy_undefined_links.insert (next_block.link.as_block_hash ());
}
lazy_state_backlog.erase (find_state);
}
@ -390,7 +390,7 @@ void nano::bootstrap_attempt_lazy::lazy_backlog_cleanup ()
}
else
{
lazy_destinations_increment (next_block.link);
lazy_destinations_increment (next_block.link.as_account ());
}
it = lazy_state_backlog.erase (it);
}

2
nano/node/confirmation_height_bounded.cpp
View file

@ -241,7 +241,7 @@ bool nano::confirmation_height_bounded::iterate (nano::read_transaction const &
auto source (block->source ());
if (source.is_zero ())
{
source = block->link ();
source = block->link ().as_block_hash ();
}
if (!source.is_zero () && !ledger.is_epoch_link (source) && ledger.store.block_exists (transaction_a, source))

2
nano/node/confirmation_height_unbounded.cpp
View file

@ -191,7 +191,7 @@ void nano::confirmation_height_unbounded::collect_unconfirmed_receive_and_source
auto source (block->source ());
if (source.is_zero ())
{
source = block->link ();
source = block->link ().as_block_hash ();
}
if (!source.is_zero () && !ledger.is_epoch_link (source) && ledger.store.block_exists (transaction_a, source))

6
nano/node/distributed_work.cpp
View file

@ -43,15 +43,15 @@ nano::distributed_work::~distributed_work ()
nano::websocket::message_builder builder;
if (status == work_generation_status::success)
{
node_l->websocket_server->broadcast (builder.work_generation (request.version, request.root, work_result, request.difficulty, node_l->default_difficulty (request.version), elapsed.value (), winner, bad_peers));
node_l->websocket_server->broadcast (builder.work_generation (request.version, request.root.as_block_hash (), work_result, request.difficulty, node_l->default_difficulty (request.version), elapsed.value (), winner, bad_peers));
}
else if (status == work_generation_status::cancelled)
{
node_l->websocket_server->broadcast (builder.work_cancelled (request.version, request.root, request.difficulty, node_l->default_difficulty (request.version), elapsed.value (), bad_peers));
node_l->websocket_server->broadcast (builder.work_cancelled (request.version, request.root.as_block_hash (), request.difficulty, node_l->default_difficulty (request.version), elapsed.value (), bad_peers));
}
else if (status == work_generation_status::failure_local || status == work_generation_status::failure_peers)
{
node_l->websocket_server->broadcast (builder.work_failed (request.version, request.root, request.difficulty, node_l->default_difficulty (request.version), elapsed.value (), bad_peers));
node_l->websocket_server->broadcast (builder.work_failed (request.version, request.root.as_block_hash (), request.difficulty, node_l->default_difficulty (request.version), elapsed.value (), bad_peers));
}
}
stop_once (true);

8
nano/node/json_handler.cpp
View file

@ -394,8 +394,8 @@ uint64_t nano::json_handler::difficulty_ledger (nano::block const & block_a)
auto link (block_a.link ());
if (!link.is_zero () && !details.is_send)
{
auto block_link (node.store.block_get (transaction, link));
if (block_link != nullptr && node.store.pending_exists (transaction, nano::pending_key (block_a.account (), link)))
auto block_link (node.store.block_get (transaction, link.as_block_hash ()));
if (block_link != nullptr && node.store.pending_exists (transaction, nano::pending_key (block_a.account (), link.as_block_hash ())))
{
details.epoch = std::max (details.epoch, block_link->sideband ().details.epoch);
details.is_receive = true;
@ -2246,7 +2246,7 @@ public:
auto previous_balance (handler.node.ledger.balance (transaction, block_a.hashables.previous));
if (balance < previous_balance)
{
if (should_ignore_account (block_a.hashables.link))
if (should_ignore_account (block_a.hashables.link.as_account ()))
{
tree.clear ();
return;
@ -2281,7 +2281,7 @@ public:
}
else
{
auto account (handler.node.ledger.account (transaction, block_a.hashables.link));
auto account (handler.node.ledger.account (transaction, block_a.hashables.link.as_block_hash ()));
if (should_ignore_account (account))
{
tree.clear ();

2
nano/node/lmdb/lmdb.cpp
View file

@ -673,7 +673,7 @@ void nano::mdb_store::upgrade_v18_to_v19 (nano::write_transaction const & transa
// Source block v18 epoch
if (old_sideband.details.is_receive)
{
auto db_val (block_raw_get_by_type_v18 (transaction_a, block_w_sideband_v18.block->link (), type_state));
auto db_val (block_raw_get_by_type_v18 (transaction_a, block_w_sideband_v18.block->link ().as_block_hash (), type_state));
if (db_val.is_initialized ())
{
nano::bufferstream stream (reinterpret_cast<uint8_t const *> (db_val.get ().data ()), db_val.get ().size ());

10
nano/node/node.cpp
View file

@ -536,13 +536,13 @@ void nano::node::process_fork (nano::transaction const & transaction_a, std::sha
nano::account account{ 0 };
if (root_block_type == nano::block_type::receive || root_block_type == nano::block_type::send || root_block_type == nano::block_type::change || root_block_type == nano::block_type::open)
{
account = this_l->ledger.store.frontier_get (transaction, root);
account = this_l->ledger.store.frontier_get (transaction, root.as_block_hash ());
}
if (!account.is_zero ())
{
this_l->bootstrap_initiator.connections->requeue_pull (nano::pull_info (account, root, root, attempt->incremental_id));
this_l->bootstrap_initiator.connections->requeue_pull (nano::pull_info (account, root.as_block_hash (), root.as_block_hash (), attempt->incremental_id));
}
else if (this_l->ledger.store.account_exists (transaction, root))
else if (this_l->ledger.store.account_exists (transaction, root.as_account ()))
{
this_l->bootstrap_initiator.connections->requeue_pull (nano::pull_info (root, nano::block_hash (0), nano::block_hash (0), attempt->incremental_id));
}
@ -1211,7 +1211,7 @@ public:
}
void state_block (nano::state_block const & block_a) override
{
scan_receivable (block_a.hashables.link);
scan_receivable (block_a.hashables.link.as_account ());
}
void send_block (nano::send_block const & block_a) override
{
@ -1265,7 +1265,7 @@ void nano::node::process_confirmed_data (nano::transaction const & transaction_a
{
is_state_send_a = true;
}
pending_account_a = state->hashables.link;
pending_account_a = state->hashables.link.as_account ();
}
if (auto send = dynamic_cast<nano::send_block *> (block_a.get ()))
{

4
nano/node/request_aggregator.cpp
View file

@ -174,12 +174,12 @@ std::vector<std::pair<nano::root, nano::block_hash>> nano::request_aggregator::a
if (block == nullptr && !hash_root.second.is_zero ())
{
// Search for block root
auto successor (ledger.store.block_successor (transaction_a, hash_root.second));
auto successor (ledger.store.block_successor (transaction_a, hash_root.second.as_block_hash ()));
// Search for account root
if (successor.is_zero ())
{
nano::account_info info;
auto error (ledger.store.account_get (transaction_a, hash_root.second, info));
auto error (ledger.store.account_get (transaction_a, hash_root.second.as_account (), info));
if (!error)
{
successor = info.open_block;

4
nano/qt/qt.cpp
View file

@ -559,7 +559,7 @@ public:
{
type = "Send";
amount = previous_balance - balance;
account = block_a.hashables.link;
account = block_a.hashables.link.as_account ();
}
else
{
@ -576,7 +576,7 @@ public:
else
{
type = "Receive";
account = ledger.account (transaction, block_a.hashables.link);
account = ledger.account (transaction, block_a.hashables.link.as_block_hash ());
}
amount = balance - previous_balance;
}

10
nano/rpc_test/rpc.cpp
View file

@ -2820,7 +2820,7 @@ TEST (rpc, work_generate_block_high)
rpc.start ();
nano::keypair key;
nano::state_block block (key.pub, 0, nano::dev_genesis_key.pub, nano::Gxrb_ratio, 123, key.prv, key.pub, *node->work_generate_blocking (key.pub));
nano::block_hash hash (block.root ());
nano::block_hash hash (block.root ().as_block_hash ());
auto block_difficulty (nano::work_difficulty (nano::work_version::work_1, hash, block.block_work ()));
boost::property_tree::ptree request;
request.put ("action", "work_generate");
@ -2853,8 +2853,8 @@ TEST (rpc, work_generate_block_low)
nano::keypair key;
nano::state_block block (key.pub, 0, nano::dev_genesis_key.pub, nano::Gxrb_ratio, 123, key.prv, key.pub, 0);
auto threshold (node->default_difficulty (block.work_version ()));
block.block_work_set (system.work_generate_limited (block.root (), threshold, nano::difficulty::from_multiplier (node->config.max_work_generate_multiplier / 10, threshold)));
nano::block_hash hash (block.root ());
block.block_work_set (system.work_generate_limited (block.root ().as_block_hash (), threshold, nano::difficulty::from_multiplier (node->config.max_work_generate_multiplier / 10, threshold)));
nano::block_hash hash (block.root ().as_block_hash ());
auto block_difficulty (block.difficulty ());
boost::property_tree::ptree request;
request.put ("action", "work_generate");
@ -2935,8 +2935,8 @@ TEST (rpc, work_generate_block_ledger_epoch_2)
rpc.start ();
nano::state_block block (key.pub, 0, nano::dev_genesis_key.pub, nano::Gxrb_ratio, send_block->hash (), key.prv, key.pub, 0);
auto threshold (nano::work_threshold (block.work_version (), nano::block_details (nano::epoch::epoch_2, false, true, false)));
block.block_work_set (system.work_generate_limited (block.root (), 1, threshold - 1));
nano::block_hash hash (block.root ());
block.block_work_set (system.work_generate_limited (block.root ().as_block_hash (), 1, threshold - 1));
nano::block_hash hash (block.root ().as_block_hash ());
boost::property_tree::ptree request;
request.put ("action", "work_generate");
request.put ("hash", hash.to_string ());

2
nano/secure/blockstore_partial.hpp
View file

@ -155,7 +155,7 @@ public:
bool root_exists (nano::transaction const & transaction_a, nano::root const & root_a) override
{
return block_exists (transaction_a, root_a) || account_exists (transaction_a, root_a);
return block_exists (transaction_a, root_a.as_block_hash ()) || account_exists (transaction_a, root_a.as_account ());
}
nano::account block_account (nano::transaction const & transaction_a, nano::block_hash const & hash_a) const override

30
nano/secure/ledger.cpp
View file

@ -133,18 +133,18 @@ public:
if (is_send)
{
nano::pending_key key (block_a.hashables.link, hash);
nano::pending_key key (block_a.hashables.link.as_account (), hash);
while (!error && !ledger.store.pending_exists (transaction, key))
{
error = ledger.rollback (transaction, ledger.latest (transaction, block_a.hashables.link), list);
error = ledger.rollback (transaction, ledger.latest (transaction, block_a.hashables.link.as_account ()), list);
}
ledger.store.pending_del (transaction, key);
ledger.stats.inc (nano::stat::type::rollback, nano::stat::detail::send);
}
else if (!block_a.hashables.link.is_zero () && !ledger.is_epoch_link (block_a.hashables.link))
{
nano::pending_info pending_info (ledger.account (transaction, block_a.hashables.link), block_a.hashables.balance.number () - balance, block_a.sideband ().source_epoch);
ledger.store.pending_put (transaction, nano::pending_key (block_a.hashables.account, block_a.hashables.link), pending_info);
nano::pending_info pending_info (ledger.account (transaction, block_a.hashables.link.as_block_hash ()), block_a.hashables.balance.number () - balance, block_a.sideband ().source_epoch);
ledger.store.pending_put (transaction, nano::pending_key (block_a.hashables.account, block_a.hashables.link.as_block_hash ()), pending_info);
ledger.stats.inc (nano::stat::type::rollback, nano::stat::detail::receive);
}
@ -316,10 +316,10 @@ void ledger_processor::state_block_impl (nano::state_block & block_a)
{
if (!block_a.hashables.link.is_zero ())
{
result.code = ledger.store.block_exists (transaction, block_a.hashables.link) ? nano::process_result::progress : nano::process_result::gap_source; // Have we seen the source block already? (Harmless)
result.code = ledger.store.block_exists (transaction, block_a.hashables.link.as_block_hash ()) ? nano::process_result::progress : nano::process_result::gap_source; // Have we seen the source block already? (Harmless)
if (result.code == nano::process_result::progress)
{
nano::pending_key key (block_a.hashables.account, block_a.hashables.link);
nano::pending_key key (block_a.hashables.account, block_a.hashables.link.as_block_hash ());
nano::pending_info pending;
result.code = ledger.store.pending_get (transaction, key, pending) ? nano::process_result::unreceivable : nano::process_result::progress; // Has this source already been received (Malformed)
if (result.code == nano::process_result::progress)
@ -360,13 +360,13 @@ void ledger_processor::state_block_impl (nano::state_block & block_a)
if (is_send)
{
nano::pending_key key (block_a.hashables.link, hash);
nano::pending_key key (block_a.hashables.link.as_account (), hash);
nano::pending_info info (block_a.hashables.account, amount.number (), epoch);
ledger.store.pending_put (transaction, key, info);
}
else if (!block_a.hashables.link.is_zero ())
{
ledger.store.pending_del (transaction, nano::pending_key (block_a.hashables.account, block_a.hashables.link));
ledger.store.pending_del (transaction, nano::pending_key (block_a.hashables.account, block_a.hashables.link.as_block_hash ()));
}
nano::account_info new_info (hash, block_a.representative (), info.open_block.is_zero () ? hash : info.open_block, block_a.hashables.balance, nano::seconds_since_epoch (), info.block_count + 1, epoch);
@ -883,7 +883,7 @@ nano::account const & nano::ledger::block_destination (nano::transaction const &
}
else if (state_block != nullptr && is_send (transaction_a, *state_block))
{
return state_block->hashables.link;
return state_block->hashables.link.as_account ();
}
static nano::account result (0);
return result;
@ -904,7 +904,7 @@ nano::block_hash nano::ledger::block_source (nano::transaction const & transacti
nano::state_block const * state_block (dynamic_cast<nano::state_block const *> (&block_a));
if (state_block != nullptr && !is_send (transaction_a, *state_block))
{
result = state_block->hashables.link;
result = state_block->hashables.link.as_block_hash ();
}
return result;
}
@ -1086,7 +1086,7 @@ public:
void state_block (nano::state_block const & block_a) override
{
result[0] = block_a.hashables.previous;
result[1] = block_a.hashables.link;
result[1] = block_a.hashables.link.as_block_hash ();
// ledger.is_send will check the sideband first, if block_a has a loaded sideband the check that previous block exists can be skipped
if (ledger.is_epoch_link (block_a.hashables.link) || ((block_a.has_sideband () || ledger.store.block_exists (transaction, block_a.hashables.previous)) && ledger.is_send (transaction, block_a)))
{
@ -1148,7 +1148,7 @@ std::shared_ptr<nano::block> nano::ledger::successor (nano::transaction const &
if (root_a.previous ().is_zero ())
{
nano::account_info info;
if (!store.account_get (transaction_a, root_a.root (), info))
if (!store.account_get (transaction_a, root_a.root ().as_account (), info))
{
successor = info.open_block;
}
@ -1179,12 +1179,12 @@ std::shared_ptr<nano::block> nano::ledger::forked_block (nano::transaction const
{
debug_assert (!store.block_exists (transaction_a, block_a.hash ()));
auto root (block_a.root ());
debug_assert (store.block_exists (transaction_a, root) || store.account_exists (transaction_a, root));
auto result (store.block_get (transaction_a, store.block_successor (transaction_a, root)));
debug_assert (store.block_exists (transaction_a, root.as_block_hash ()) || store.account_exists (transaction_a, root.as_account ()));
auto result (store.block_get (transaction_a, store.block_successor (transaction_a, root.as_block_hash ())));
if (result == nullptr)
{
nano::account_info info;
auto error (store.account_get (transaction_a, root, info));
auto error (store.account_get (transaction_a, root.as_account (), info));
(void)error;
debug_assert (!error);
result = store.block_get (transaction_a, info.open_block);