diff --git a/libraries/chain/controller.cpp b/libraries/chain/controller.cpp index df41be91b5..555ddd6dbf 100644 --- a/libraries/chain/controller.cpp +++ b/libraries/chain/controller.cpp @@ -342,8 +342,9 @@ struct controller_impl { set_activation_handler(); set_activation_handler(); - self.irreversible_block.connect([this](const block_state_legacy_ptr& bsp) { - wasmif.current_lib(bsp->block_num); + self.irreversible_block.connect([this](const block_signal_params& t) { + const auto& [ block, id] = t; + wasmif.current_lib(block->block_num()); }); @@ -368,7 +369,7 @@ struct controller_impl { } /** - * Plugins / observers listening to signals emited (such as accepted_transaction) might trigger + * Plugins / observers listening to signals emited might trigger * errors and throw exceptions. Unless those exceptions are caught it could impact consensus and/or * cause a node to fork. * @@ -448,7 +449,7 @@ struct controller_impl { apply_block( br, *bitr, controller::block_status::complete, trx_meta_cache_lookup{} ); } - emit( self.irreversible_block, *bitr ); + emit( self.irreversible_block, std::tie((*bitr)->block, (*bitr)->id) ); // blog.append could fail due to failures like running out of space. // Do it before commit so that in case it throws, DB can be rolled back. @@ -1336,7 +1337,6 @@ struct controller_impl { pending->_block_report.total_cpu_usage_us += billed_cpu_time_us; pending->_block_report.total_elapsed_time += trace->elapsed; pending->_block_report.total_time += trace->elapsed; - emit( self.accepted_transaction, trx ); dmlog_applied_transaction(trace); emit( self.applied_transaction, std::tie(trace, trx->packed_trx()) ); undo_session.squash(); @@ -1402,7 +1402,6 @@ struct controller_impl { trace->account_ram_delta = account_delta( gtrx.payer, trx_removal_ram_delta ); - emit( self.accepted_transaction, trx ); dmlog_applied_transaction(trace); emit( self.applied_transaction, std::tie(trace, trx->packed_trx()) ); @@ -1447,7 +1446,6 @@ struct controller_impl { if( !trace->except_ptr ) { trace->account_ram_delta = account_delta( gtrx.payer, trx_removal_ram_delta ); trace->elapsed = fc::time_point::now() - start; - emit( self.accepted_transaction, trx ); dmlog_applied_transaction(trace); emit( self.applied_transaction, std::tie(trace, trx->packed_trx()) ); undo_session.squash(); @@ -1493,13 +1491,11 @@ struct controller_impl { trace->receipt = push_receipt(gtrx.trx_id, transaction_receipt::hard_fail, cpu_time_to_bill_us, 0); trace->account_ram_delta = account_delta( gtrx.payer, trx_removal_ram_delta ); - emit( self.accepted_transaction, trx ); dmlog_applied_transaction(trace); emit( self.applied_transaction, std::tie(trace, trx->packed_trx()) ); undo_session.squash(); } else { - emit( self.accepted_transaction, trx ); dmlog_applied_transaction(trace); emit( self.applied_transaction, std::tie(trace, trx->packed_trx()) ); } @@ -1633,7 +1629,6 @@ struct controller_impl { // call the accept signal but only once for this transaction if (!trx->accepted) { trx->accepted = true; - emit(self.accepted_transaction, trx); } dmlog_applied_transaction(trace, &trn); @@ -1680,7 +1675,6 @@ struct controller_impl { } if (!trx->is_transient()) { - emit(self.accepted_transaction, trx); dmlog_applied_transaction(trace); emit(self.applied_transaction, std::tie(trace, trx->packed_trx())); @@ -1950,7 +1944,7 @@ struct controller_impl { if( s == controller::block_status::incomplete ) { fork_db.add( bsp ); fork_db.mark_valid( bsp ); - emit( self.accepted_block_header, bsp ); + emit( self.accepted_block_header, std::tie(bsp->block, bsp->id) ); EOS_ASSERT( bsp == fork_db.head(), fork_database_exception, "committed block did not become the new head in fork database"); } else if (s != controller::block_status::irreversible) { fork_db.mark_valid( bsp ); @@ -1962,7 +1956,7 @@ struct controller_impl { dm_logger->on_accepted_block(bsp); } - emit( self.accepted_block, bsp ); + emit( self.accepted_block, std::tie(bsp->block, bsp->id) ); if( s == controller::block_status::incomplete ) { log_irreversible(); @@ -2258,15 +2252,13 @@ struct controller_impl { return; } - emit( self.pre_accepted_block, b ); - fork_db.add( bsp ); if (self.is_trusted_producer(b->producer)) { trusted_producer_light_validation = true; }; - emit( self.accepted_block_header, bsp ); + emit( self.accepted_block_header, std::tie(bsp->block, bsp->id) ); if( read_mode != db_read_mode::IRREVERSIBLE ) { maybe_switch_forks( br, fork_db.pending_head(), s, forked_branch_cb, trx_lookup ); @@ -2293,7 +2285,6 @@ struct controller_impl { return; } - emit( self.pre_accepted_block, b ); const bool skip_validate_signee = !conf.force_all_checks; auto bsp = std::make_shared( @@ -2311,7 +2302,7 @@ struct controller_impl { fork_db.add( bsp, true ); } - emit( self.accepted_block_header, bsp ); + emit( self.accepted_block_header, std::tie(bsp->block, bsp->id) ); controller::block_report br; if( s == controller::block_status::irreversible ) { @@ -2319,7 +2310,7 @@ struct controller_impl { // On replay, log_irreversible is not called and so no irreversible_block signal is emitted. // So emit it explicitly here. - emit( self.irreversible_block, bsp ); + emit( self.irreversible_block, std::tie(bsp->block, bsp->id) ); if (!self.skip_db_sessions(s)) { db.commit(bsp->block_num); diff --git a/libraries/chain/include/eosio/chain/controller.hpp b/libraries/chain/include/eosio/chain/controller.hpp index ca24e4da35..83f38b1951 100644 --- a/libraries/chain/include/eosio/chain/controller.hpp +++ b/libraries/chain/include/eosio/chain/controller.hpp @@ -44,6 +44,8 @@ namespace eosio { namespace chain { // lookup transaction_metadata via supplied function to avoid re-creation using trx_meta_cache_lookup = std::function; + using block_signal_params = std::tuple; + class fork_database; enum class db_read_mode { @@ -326,24 +328,11 @@ namespace eosio { namespace chain { static std::optional convert_exception_to_error_code( const fc::exception& e ); - signal block_start; // block_num - signal pre_accepted_block; - signal accepted_block_header; - signal accepted_block; - signal irreversible_block; - signal accepted_transaction; + signal block_start; + signal accepted_block_header; + signal accepted_block; + signal irreversible_block; signal)> applied_transaction; - signal bad_alloc; - - /* - signal pre_apply_block; - signal post_apply_block; - signal abort_apply_block; - signal pre_apply_transaction; - signal post_apply_transaction; - signal pre_apply_action; - signal post_apply_action; - */ const apply_handler* find_apply_handler( account_name contract, scope_name scope, action_name act )const; wasm_interface& get_wasm_interface(); diff --git a/libraries/chain/include/eosio/chain/subjective_billing.hpp b/libraries/chain/include/eosio/chain/subjective_billing.hpp index 839e9edba9..cec47e8092 100644 --- a/libraries/chain/include/eosio/chain/subjective_billing.hpp +++ b/libraries/chain/include/eosio/chain/subjective_billing.hpp @@ -2,7 +2,6 @@ #include #include -#include #include #include #include @@ -81,9 +80,9 @@ class subjective_billing { } } - void remove_subjective_billing( const chain::block_state_legacy_ptr& bsp, uint32_t time_ordinal ) { + void remove_subjective_billing( const chain::signed_block_ptr& block, uint32_t time_ordinal ) { if( !_trx_cache_index.empty() ) { - for( const auto& receipt : bsp->block->transactions ) { + for( const auto& receipt : block->transactions ) { if( std::holds_alternative(receipt.trx) ) { const auto& pt = std::get(receipt.trx); remove_subjective_billing( pt.id(), time_ordinal ); @@ -151,11 +150,11 @@ class subjective_billing { } } - void on_block( fc::logger& log, const chain::block_state_legacy_ptr& bsp, const fc::time_point& now ) { - if( bsp == nullptr || _disabled ) return; + void on_block( fc::logger& log, const chain::signed_block_ptr& block, const fc::time_point& now ) { + if( block == nullptr || _disabled ) return; const auto time_ordinal = time_ordinal_for(now); const auto orig_count = _account_subjective_bill_cache.size(); - remove_subjective_billing( bsp, time_ordinal ); + remove_subjective_billing( block, time_ordinal ); if (orig_count > 0) { fc_dlog( log, "Subjective billed accounts ${n} removed ${r}", ("n", orig_count)("r", orig_count - _account_subjective_bill_cache.size()) ); diff --git a/libraries/chain/include/eosio/chain/unapplied_transaction_queue.hpp b/libraries/chain/include/eosio/chain/unapplied_transaction_queue.hpp index a413652297..4480c06abc 100644 --- a/libraries/chain/include/eosio/chain/unapplied_transaction_queue.hpp +++ b/libraries/chain/include/eosio/chain/unapplied_transaction_queue.hpp @@ -114,10 +114,10 @@ class unapplied_transaction_queue { return true; } - void clear_applied( const block_state_legacy_ptr& bs ) { + void clear_applied( const signed_block_ptr& block ) { if( empty() ) return; auto& idx = queue.get(); - for( const auto& receipt : bs->block->transactions ) { + for( const auto& receipt : block->transactions ) { if( std::holds_alternative(receipt.trx) ) { const auto& pt = std::get(receipt.trx); auto itr = idx.find( pt.id() ); diff --git a/libraries/state_history/include/eosio/state_history/trace_converter.hpp b/libraries/state_history/include/eosio/state_history/trace_converter.hpp index 24bfa5872b..4cc6bef7cd 100644 --- a/libraries/state_history/include/eosio/state_history/trace_converter.hpp +++ b/libraries/state_history/include/eosio/state_history/trace_converter.hpp @@ -1,13 +1,11 @@ #pragma once -#include #include #include namespace eosio { namespace state_history { -using chain::block_state_legacy_ptr; using chain::transaction_id_type; struct trace_converter { @@ -15,7 +13,7 @@ struct trace_converter { std::optional onblock_trace; void add_transaction(const transaction_trace_ptr& trace, const chain::packed_transaction_ptr& transaction); - void pack(boost::iostreams::filtering_ostreambuf& ds, bool trace_debug_mode, const block_state_legacy_ptr& block_state_legacy); + void pack(boost::iostreams::filtering_ostreambuf& ds, bool trace_debug_mode, const chain::signed_block_ptr& block); }; } // namespace state_history diff --git a/libraries/state_history/trace_converter.cpp b/libraries/state_history/trace_converter.cpp index 7d86e5cd8a..3c137f5ecf 100644 --- a/libraries/state_history/trace_converter.cpp +++ b/libraries/state_history/trace_converter.cpp @@ -15,11 +15,11 @@ void trace_converter::add_transaction(const transaction_trace_ptr& trace, const } } -void trace_converter::pack(boost::iostreams::filtering_ostreambuf& obuf, bool trace_debug_mode, const block_state_legacy_ptr& block_state) { +void trace_converter::pack(boost::iostreams::filtering_ostreambuf& obuf, bool trace_debug_mode, const chain::signed_block_ptr& block) { std::vector traces; if (onblock_trace) traces.push_back(*onblock_trace); - for (auto& r : block_state->block->transactions) { + for (auto& r : block->transactions) { transaction_id_type id; if (std::holds_alternative(r.trx)) id = std::get(r.trx); diff --git a/libraries/testing/tester.cpp b/libraries/testing/tester.cpp index 10140d16a8..51672db7ad 100644 --- a/libraries/testing/tester.cpp +++ b/libraries/testing/tester.cpp @@ -321,9 +321,10 @@ namespace eosio { namespace testing { control->add_indices(); if (lambda) lambda(); chain_transactions.clear(); - control->accepted_block.connect([this]( const block_state_legacy_ptr& block_state ){ - FC_ASSERT( block_state->block ); - for( auto receipt : block_state->block->transactions ) { + control->accepted_block.connect([this]( block_signal_params t ){ + const auto& [ block, id ] = t; + FC_ASSERT( block ); + for( auto receipt : block->transactions ) { if( std::holds_alternative(receipt.trx) ) { auto &pt = std::get(receipt.trx); chain_transactions[pt.get_transaction().id()] = std::move(receipt); diff --git a/plugins/chain_interface/include/eosio/chain/plugin_interface.hpp b/plugins/chain_interface/include/eosio/chain/plugin_interface.hpp index 23205bc96a..4fe1c247d4 100644 --- a/plugins/chain_interface/include/eosio/chain/plugin_interface.hpp +++ b/plugins/chain_interface/include/eosio/chain/plugin_interface.hpp @@ -14,12 +14,10 @@ namespace eosio::chain::plugin_interface { struct chain_plugin_interface; namespace channels { - using pre_accepted_block = channel_decl; using rejected_block = channel_decl; - using accepted_block_header = channel_decl; - using accepted_block = channel_decl; - using irreversible_block = channel_decl; - using accepted_transaction = channel_decl; + using accepted_block_header = channel_decl; + using accepted_block = channel_decl; + using irreversible_block = channel_decl; using applied_transaction = channel_decl; } diff --git a/plugins/chain_plugin/account_query_db.cpp b/plugins/chain_plugin/account_query_db.cpp index 1d6a4ebaa2..f5a6cf6a32 100644 --- a/plugins/chain_plugin/account_query_db.cpp +++ b/plugins/chain_plugin/account_query_db.cpp @@ -194,9 +194,9 @@ namespace eosio::chain_apis { key_bimap.right.erase(key_range.first, key_range.second); } - bool is_rollback_required( const chain::block_state_legacy_ptr& bsp ) const { + bool is_rollback_required( const chain::signed_block_ptr& block ) const { std::shared_lock read_lock(rw_mutex); - const auto bnum = bsp->block->block_num(); + const auto bnum = block->block_num(); const auto& index = permission_info_index.get(); if (index.empty()) { @@ -231,10 +231,10 @@ namespace eosio::chain_apis { * * For each removed entry, this will create a new entry if there exists an equivalent {owner, name} permission * at the HEAD state of the chain. - * @param bsp - the block to rollback before + * @param block - the block to rollback before */ - void rollback_to_before( const chain::block_state_legacy_ptr& bsp ) { - const auto bnum = bsp->block->block_num(); + void rollback_to_before( const chain::signed_block_ptr& block ) { + const auto bnum = block->block_num(); auto& index = permission_info_index.get(); const auto& permission_by_owner = controller.db().get_index().indices().get(); @@ -265,8 +265,8 @@ namespace eosio::chain_apis { } else { const auto& po = *itr; - uint32_t last_updated_height = chain::block_timestamp_type(po.last_updated) == bsp->header.timestamp ? - bsp->block_num : last_updated_time_to_height(po.last_updated); + uint32_t last_updated_height = chain::block_timestamp_type(po.last_updated) == block->timestamp ? + bnum : last_updated_time_to_height(po.last_updated); index.modify(index.iterator_to(pi), [&po, last_updated_height](auto& mutable_pi) { mutable_pi.last_updated_height = last_updated_height; @@ -303,9 +303,9 @@ namespace eosio::chain_apis { /** * Pre-Commit step with const qualifier to guarantee it does not mutate * the thread-safe data set - * @param bsp + * @param block */ - auto commit_block_prelock( const chain::block_state_legacy_ptr& bsp ) const { + auto commit_block_prelock( const chain::signed_block_ptr& block ) const { permission_set_t updated; permission_set_t deleted; @@ -338,7 +338,7 @@ namespace eosio::chain_apis { if( onblock_trace ) process_trace(*onblock_trace); - for( const auto& r : bsp->block->transactions ) { + for( const auto& r : block->transactions ) { chain::transaction_id_type id; if( std::holds_alternative(r.trx)) { id = std::get(r.trx); @@ -352,31 +352,32 @@ namespace eosio::chain_apis { } } - return std::make_tuple(std::move(updated), std::move(deleted), is_rollback_required(bsp)); + return std::make_tuple(std::move(updated), std::move(deleted), is_rollback_required(block)); } /** * Commit a block of transactions to the account query DB * transaction traces need to be in the cache prior to this call - * @param bsp + * @param block */ - void commit_block(const chain::block_state_legacy_ptr& bsp ) { + void commit_block(const chain::signed_block_ptr& block) { permission_set_t updated; permission_set_t deleted; bool rollback_required = false; - std::tie(updated, deleted, rollback_required) = commit_block_prelock(bsp); + std::tie(updated, deleted, rollback_required) = commit_block_prelock(block); // optimistic skip of locking section if there is nothing to do if (!updated.empty() || !deleted.empty() || rollback_required) { std::unique_lock write_lock(rw_mutex); + auto block_num = block->block_num(); - rollback_to_before(bsp); + rollback_to_before(block); // insert this blocks time into the time map - time_to_block_num.emplace(bsp->header.timestamp, bsp->block_num); + time_to_block_num.emplace(block->timestamp, block_num); - const auto bnum = bsp->block_num; + const auto bnum = block_num; auto& index = permission_info_index.get(); const auto& permission_by_owner = controller.db().get_index().indices().get(); @@ -520,7 +521,7 @@ namespace eosio::chain_apis { } FC_LOG_AND_DROP(("ACCOUNT DB cache_transaction_trace ERROR")); } - void account_query_db::commit_block(const chain::block_state_legacy_ptr& block ) { + void account_query_db::commit_block( const chain::signed_block_ptr& block ) { try { _impl->commit_block(block); } FC_LOG_AND_DROP(("ACCOUNT DB commit_block ERROR")); diff --git a/plugins/chain_plugin/chain_plugin.cpp b/plugins/chain_plugin/chain_plugin.cpp index f3ebc7d614..d5d1b91b74 100644 --- a/plugins/chain_plugin/chain_plugin.cpp +++ b/plugins/chain_plugin/chain_plugin.cpp @@ -154,11 +154,9 @@ using boost::signals2::scoped_connection; class chain_plugin_impl { public: chain_plugin_impl() - :pre_accepted_block_channel(app().get_channel()) - ,accepted_block_header_channel(app().get_channel()) + :accepted_block_header_channel(app().get_channel()) ,accepted_block_channel(app().get_channel()) ,irreversible_block_channel(app().get_channel()) - ,accepted_transaction_channel(app().get_channel()) ,applied_transaction_channel(app().get_channel()) ,incoming_block_sync_method(app().get_method()) ,incoming_transaction_async_method(app().get_method()) @@ -181,11 +179,9 @@ class chain_plugin_impl { // retained references to channels for easy publication - channels::pre_accepted_block::channel_type& pre_accepted_block_channel; channels::accepted_block_header::channel_type& accepted_block_header_channel; channels::accepted_block::channel_type& accepted_block_channel; channels::irreversible_block::channel_type& irreversible_block_channel; - channels::accepted_transaction::channel_type& accepted_transaction_channel; channels::applied_transaction::channel_type& applied_transaction_channel; // retained references to methods for easy calling @@ -199,11 +195,9 @@ class chain_plugin_impl { methods::get_last_irreversible_block_number::method_type::handle get_last_irreversible_block_number_provider; // scoped connections for chain controller - std::optional pre_accepted_block_connection; std::optional accepted_block_header_connection; std::optional accepted_block_connection; std::optional irreversible_block_connection; - std::optional accepted_transaction_connection; std::optional applied_transaction_connection; std::optional block_start_connection; @@ -1019,72 +1013,58 @@ void chain_plugin_impl::plugin_initialize(const variables_map& options) { } ); // relay signals to channels - pre_accepted_block_connection = chain->pre_accepted_block.connect([this](const signed_block_ptr& blk) { - auto itr = loaded_checkpoints.find( blk->block_num() ); - if( itr != loaded_checkpoints.end() ) { - auto id = blk->calculate_id(); - EOS_ASSERT( itr->second == id, checkpoint_exception, - "Checkpoint does not match for block number ${num}: expected: ${expected} actual: ${actual}", - ("num", blk->block_num())("expected", itr->second)("actual", id) - ); - } - - pre_accepted_block_channel.publish(priority::medium, blk); - }); - accepted_block_header_connection = chain->accepted_block_header.connect( - [this]( const block_state_legacy_ptr& blk ) { - accepted_block_header_channel.publish( priority::medium, blk ); + [this]( const block_signal_params& t ) { + accepted_block_header_channel.publish( priority::medium, t ); } ); - accepted_block_connection = chain->accepted_block.connect( [this]( const block_state_legacy_ptr& blk ) { + accepted_block_connection = chain->accepted_block.connect( [this]( const block_signal_params& t ) { + const auto& [ block, id ] = t; if (_account_query_db) { - _account_query_db->commit_block(blk); + _account_query_db->commit_block(block); } if (_trx_retry_db) { - _trx_retry_db->on_accepted_block(blk); + _trx_retry_db->on_accepted_block(block->block_num()); } if (_trx_finality_status_processing) { - _trx_finality_status_processing->signal_accepted_block(blk); + _trx_finality_status_processing->signal_accepted_block(block, id); } - accepted_block_channel.publish( priority::high, blk ); + accepted_block_channel.publish( priority::high, t ); } ); - irreversible_block_connection = chain->irreversible_block.connect( [this]( const block_state_legacy_ptr& blk ) { + irreversible_block_connection = chain->irreversible_block.connect( [this]( const block_signal_params& t ) { + const auto& [ block, id ] = t; + if (_trx_retry_db) { - _trx_retry_db->on_irreversible_block(blk); + _trx_retry_db->on_irreversible_block(block); } if (_trx_finality_status_processing) { - _trx_finality_status_processing->signal_irreversible_block(blk); + _trx_finality_status_processing->signal_irreversible_block(block, id); } - irreversible_block_channel.publish( priority::low, blk ); + irreversible_block_channel.publish( priority::low, t ); } ); - - accepted_transaction_connection = chain->accepted_transaction.connect( - [this]( const transaction_metadata_ptr& meta ) { - accepted_transaction_channel.publish( priority::low, meta ); - } ); - + applied_transaction_connection = chain->applied_transaction.connect( [this]( std::tuple t ) { + const auto& [ trace, ptrx ] = t; if (_account_query_db) { - _account_query_db->cache_transaction_trace(std::get<0>(t)); + _account_query_db->cache_transaction_trace(trace); } if (_trx_retry_db) { - _trx_retry_db->on_applied_transaction(std::get<0>(t), std::get<1>(t)); + _trx_retry_db->on_applied_transaction(trace, ptrx); } if (_trx_finality_status_processing) { - _trx_finality_status_processing->signal_applied_transaction(std::get<0>(t), std::get<1>(t)); + _trx_finality_status_processing->signal_applied_transaction(trace, ptrx); } - applied_transaction_channel.publish( priority::low, std::get<0>(t) ); + applied_transaction_channel.publish( priority::low, trace ); } ); if (_trx_finality_status_processing || _trx_retry_db) { @@ -1162,11 +1142,9 @@ void chain_plugin::plugin_startup() { } void chain_plugin_impl::plugin_shutdown() { - pre_accepted_block_connection.reset(); accepted_block_header_connection.reset(); accepted_block_connection.reset(); irreversible_block_connection.reset(); - accepted_transaction_connection.reset(); applied_transaction_connection.reset(); block_start_connection.reset(); chain.reset(); diff --git a/plugins/chain_plugin/include/eosio/chain_plugin/account_query_db.hpp b/plugins/chain_plugin/include/eosio/chain_plugin/account_query_db.hpp index 164564057e..2b360e28db 100644 --- a/plugins/chain_plugin/include/eosio/chain_plugin/account_query_db.hpp +++ b/plugins/chain_plugin/include/eosio/chain_plugin/account_query_db.hpp @@ -1,6 +1,5 @@ #pragma once #include -#include #include namespace eosio::chain_apis { @@ -40,7 +39,7 @@ namespace eosio::chain_apis { * uncommitted traces. * @param block */ - void commit_block(const chain::block_state_legacy_ptr& block ); + void commit_block( const chain::signed_block_ptr& block ); /** * parameters for the get_accounts_by_authorizers RPC diff --git a/plugins/chain_plugin/include/eosio/chain_plugin/trx_finality_status_processing.hpp b/plugins/chain_plugin/include/eosio/chain_plugin/trx_finality_status_processing.hpp index 327fe7610d..b092f38320 100644 --- a/plugins/chain_plugin/include/eosio/chain_plugin/trx_finality_status_processing.hpp +++ b/plugins/chain_plugin/include/eosio/chain_plugin/trx_finality_status_processing.hpp @@ -1,6 +1,5 @@ #pragma once #include -#include #include #include @@ -42,9 +41,9 @@ namespace eosio::chain_apis { void signal_applied_transaction( const chain::transaction_trace_ptr& trace, const chain::packed_transaction_ptr& ptrx ); - void signal_accepted_block( const chain::block_state_legacy_ptr& bsp ); + void signal_accepted_block( const chain::signed_block_ptr& block, const chain::block_id_type& id ); - void signal_irreversible_block( const chain::block_state_legacy_ptr& bsp ); + void signal_irreversible_block( const chain::signed_block_ptr& block, const chain::block_id_type& id ); void signal_block_start( uint32_t block_num ); diff --git a/plugins/chain_plugin/include/eosio/chain_plugin/trx_retry_db.hpp b/plugins/chain_plugin/include/eosio/chain_plugin/trx_retry_db.hpp index 201ce61322..7ffb041e0b 100644 --- a/plugins/chain_plugin/include/eosio/chain_plugin/trx_retry_db.hpp +++ b/plugins/chain_plugin/include/eosio/chain_plugin/trx_retry_db.hpp @@ -1,6 +1,5 @@ #pragma once #include -#include #include namespace eosio::chain_apis { @@ -64,12 +63,12 @@ class trx_retry_db { /** * Attach to chain accepted_block signal */ - void on_accepted_block(const chain::block_state_legacy_ptr& block ); + void on_accepted_block( uint32_t block_num ); /** * Attach to chain irreversible_block signal */ - void on_irreversible_block(const chain::block_state_legacy_ptr& block ); + void on_irreversible_block( const chain::signed_block_ptr& block ); private: std::unique_ptr _impl; diff --git a/plugins/chain_plugin/test/test_account_query_db.cpp b/plugins/chain_plugin/test/test_account_query_db.cpp index ff168c87a1..cd02c1627a 100644 --- a/plugins/chain_plugin/test/test_account_query_db.cpp +++ b/plugins/chain_plugin/test/test_account_query_db.cpp @@ -2,7 +2,6 @@ #include #include #include -#include #include #include @@ -38,8 +37,9 @@ BOOST_FIXTURE_TEST_CASE(newaccount_test, validating_tester) { try { auto aq_db = account_query_db(*control); //link aq_db to the `accepted_block` signal on the controller - auto c2 = control->accepted_block.connect([&](const block_state_legacy_ptr& blk) { - aq_db.commit_block( blk); + auto c2 = control->accepted_block.connect([&](const block_signal_params& t) { + const auto& [ block, id ] = t; + aq_db.commit_block( block ); }); produce_blocks(10); @@ -63,8 +63,9 @@ BOOST_FIXTURE_TEST_CASE(updateauth_test, validating_tester) { try { auto aq_db = account_query_db(*control); //link aq_db to the `accepted_block` signal on the controller - auto c = control->accepted_block.connect([&](const block_state_legacy_ptr& blk) { - aq_db.commit_block( blk); + auto c = control->accepted_block.connect([&](const block_signal_params& t) { + const auto& [ block, id ] = t; + aq_db.commit_block( block ); }); produce_blocks(10); @@ -97,8 +98,9 @@ BOOST_FIXTURE_TEST_CASE(updateauth_test_multi_threaded, validating_tester) { try auto aq_db = account_query_db(*control); //link aq_db to the `accepted_block` signal on the controller - auto c = control->accepted_block.connect([&](const block_state_legacy_ptr& blk) { - aq_db.commit_block( blk); + auto c = control->accepted_block.connect([&](const block_signal_params& t) { + const auto& [ block, id ] = t; + aq_db.commit_block( block ); }); produce_blocks(10); @@ -149,8 +151,9 @@ BOOST_AUTO_TEST_CASE(future_fork_test) { try { auto aq_db = account_query_db(*node_a.control); //link aq_db to the `accepted_block` signal on the controller - auto c = node_a.control->accepted_block.connect([&](const block_state_legacy_ptr& blk) { - aq_db.commit_block( blk); + auto c = node_a.control->accepted_block.connect([&](const block_signal_params& t) { + const auto& [ block, id ] = t; + aq_db.commit_block( block ); }); // create 10 blocks synced @@ -196,8 +199,9 @@ BOOST_AUTO_TEST_CASE(fork_test) { try { auto aq_db = account_query_db(*node_a.control); //link aq_db to the `accepted_block` signal on the controller - auto c = node_a.control->accepted_block.connect([&](const block_state_legacy_ptr& blk) { - aq_db.commit_block( blk); + auto c = node_a.control->accepted_block.connect([&](const block_signal_params& t) { + const auto& [ block, id ] = t; + aq_db.commit_block( block ); }); // create 10 blocks synced diff --git a/plugins/chain_plugin/test/test_trx_finality_status_processing.cpp b/plugins/chain_plugin/test/test_trx_finality_status_processing.cpp index a992578f49..770fe31e46 100644 --- a/plugins/chain_plugin/test/test_trx_finality_status_processing.cpp +++ b/plugins/chain_plugin/test/test_trx_finality_status_processing.cpp @@ -254,7 +254,7 @@ BOOST_AUTO_TEST_CASE(trx_finality_status_logic) { try { const auto block_20_time = set_now("2022-04-04", "04:44:44.500"); add(trx_pairs_20, bs_20); add(trx_pairs_20, bs_20); - status.signal_accepted_block(bs_20); + status.signal_accepted_block(bs_20->block, bs_20->id); cs = status.get_chain_state(); @@ -321,7 +321,7 @@ BOOST_AUTO_TEST_CASE(trx_finality_status_logic) { try { fc::logger::get(DEFAULT_LOGGER).set_log_level(fc::log_level::debug); add(trx_pairs_21, bs_21); - status.signal_accepted_block(bs_21); + status.signal_accepted_block(bs_21->block, bs_21->id); cs = status.get_chain_state(); BOOST_CHECK(cs.head_id == bs_21->id); @@ -390,7 +390,7 @@ BOOST_AUTO_TEST_CASE(trx_finality_status_logic) { try { status.signal_block_start(bn); add(trx_pairs_22, bs_22); - status.signal_accepted_block(bs_22); + status.signal_accepted_block(bs_22->block, bs_22->id); cs = status.get_chain_state(); BOOST_CHECK(cs.head_id == bs_22->id); @@ -468,7 +468,7 @@ BOOST_AUTO_TEST_CASE(trx_finality_status_logic) { try { status.signal_block_start(bn); add(trx_pairs_22_alt, bs_22_alt); - status.signal_accepted_block(bs_22_alt); + status.signal_accepted_block(bs_22_alt->block, bs_22_alt->id); cs = status.get_chain_state(); BOOST_CHECK(cs.head_id == bs_22_alt->id); @@ -553,7 +553,7 @@ BOOST_AUTO_TEST_CASE(trx_finality_status_logic) { try { status.signal_block_start(bn); add(trx_pairs_19, bs_19); - status.signal_accepted_block(bs_19); + status.signal_accepted_block(bs_19->block, bs_19->id); cs = status.get_chain_state(); BOOST_CHECK(cs.head_id == bs_19->id); @@ -661,7 +661,7 @@ BOOST_AUTO_TEST_CASE(trx_finality_status_logic) { try { status.signal_applied_transaction(trace, txn); } - status.signal_accepted_block(bs_19_alt); + status.signal_accepted_block(bs_19_alt->block, bs_19_alt->id); cs = status.get_chain_state(); BOOST_CHECK(cs.head_id == bs_19_alt->id); @@ -750,7 +750,7 @@ BOOST_AUTO_TEST_CASE(trx_finality_status_logic) { try { BOOST_REQUIRE(!ts); // irreversible - status.signal_irreversible_block(bs_19_alt); + status.signal_irreversible_block(bs_19_alt->block, bs_19_alt->id); cs = status.get_chain_state(); BOOST_CHECK(cs.head_id == bs_19_alt->id); @@ -898,7 +898,7 @@ namespace { status.signal_applied_transaction(trace, txn); } - status.signal_accepted_block(bs); + status.signal_accepted_block(bs->block, bs->id); } void send_spec_block() { diff --git a/plugins/chain_plugin/test/test_trx_retry_db.cpp b/plugins/chain_plugin/test/test_trx_retry_db.cpp index da7a3984b4..f9810b30bd 100644 --- a/plugins/chain_plugin/test/test_trx_retry_db.cpp +++ b/plugins/chain_plugin/test/test_trx_retry_db.cpp @@ -276,8 +276,8 @@ BOOST_AUTO_TEST_CASE(trx_retry_logic) { // signal block, nothing should be expired as now has not changed auto bsp1 = make_block_state(1, {}); trx_retry.on_block_start(1); - trx_retry.on_accepted_block(bsp1); - trx_retry.on_irreversible_block(bsp1); + trx_retry.on_accepted_block(bsp1->block_num); + trx_retry.on_irreversible_block(bsp1->block); BOOST_CHECK(!trx_1_expired); BOOST_CHECK(!trx_2_expired); // increase time by 3 seconds to expire first @@ -286,8 +286,8 @@ BOOST_AUTO_TEST_CASE(trx_retry_logic) { // signal block, first transaction should expire auto bsp2 = make_block_state(2, {}); trx_retry.on_block_start(2); - trx_retry.on_accepted_block(bsp2); - trx_retry.on_irreversible_block(bsp2); + trx_retry.on_accepted_block(bsp2->block_num); + trx_retry.on_irreversible_block(bsp2->block); BOOST_CHECK(trx_1_expired); BOOST_CHECK(!trx_2_expired); // increase time by 2 seconds to expire second @@ -296,8 +296,8 @@ BOOST_AUTO_TEST_CASE(trx_retry_logic) { // signal block, second transaction should expire auto bsp3 = make_block_state(3, {}); trx_retry.on_block_start(3); - trx_retry.on_accepted_block(bsp3); - trx_retry.on_irreversible_block(bsp3); + trx_retry.on_accepted_block(bsp3->block_num); + trx_retry.on_irreversible_block(bsp3->block); BOOST_CHECK(trx_1_expired); BOOST_CHECK(trx_2_expired); BOOST_CHECK_EQUAL(0u, trx_retry.size()); @@ -328,7 +328,7 @@ BOOST_AUTO_TEST_CASE(trx_retry_logic) { // signal block, transaction 3 should be sent auto bsp4 = make_block_state(4, {}); trx_retry.on_block_start(4); - trx_retry.on_accepted_block(bsp4); + trx_retry.on_accepted_block(bsp4->block_num); BOOST_CHECK( get_id(transactions_acked.pop().second) == 3 ); BOOST_CHECK_EQUAL( 0u, transactions_acked.size() ); // increase time by 1 seconds, so trx_4 is sent @@ -337,7 +337,7 @@ BOOST_AUTO_TEST_CASE(trx_retry_logic) { // signal block, transaction 4 should be sent auto bsp5 = make_block_state(5, {}); trx_retry.on_block_start(5); - trx_retry.on_accepted_block(bsp5); + trx_retry.on_accepted_block(bsp5->block_num); BOOST_CHECK( get_id(transactions_acked.pop().second) == 4 ); BOOST_CHECK_EQUAL( 0u, transactions_acked.size() ); BOOST_CHECK(!trx_3_expired); @@ -347,10 +347,10 @@ BOOST_AUTO_TEST_CASE(trx_retry_logic) { fc::mock_time_traits::set_now(pnow); auto bsp6 = make_block_state(6, {}); trx_retry.on_block_start(6); - trx_retry.on_accepted_block(bsp6); - trx_retry.on_irreversible_block(bsp4); - trx_retry.on_irreversible_block(bsp5); - trx_retry.on_irreversible_block(bsp6); + trx_retry.on_accepted_block(bsp6->block_num); + trx_retry.on_irreversible_block(bsp4->block); + trx_retry.on_irreversible_block(bsp5->block); + trx_retry.on_irreversible_block(bsp6->block); BOOST_CHECK(trx_3_expired); BOOST_CHECK(trx_4_expired); BOOST_CHECK_EQUAL(0u, trx_retry.size()); @@ -378,7 +378,7 @@ BOOST_AUTO_TEST_CASE(trx_retry_logic) { // not in block 7, so not returned to user auto bsp7 = make_block_state(7, {}); trx_retry.on_block_start(7); - trx_retry.on_accepted_block(bsp7); + trx_retry.on_accepted_block(bsp7->block_num); BOOST_CHECK(!trx_5_variant); BOOST_CHECK(!trx_6_variant); // 5,6 in block 8 @@ -390,7 +390,7 @@ BOOST_AUTO_TEST_CASE(trx_retry_logic) { trx_retry.on_applied_transaction(trace_5, trx_5); trx_retry.on_applied_transaction(trace_6, trx_6); auto bsp8 = make_block_state(8, {trx_5, trx_6}); - trx_retry.on_accepted_block(bsp8); + trx_retry.on_accepted_block(bsp8->block_num); BOOST_CHECK(!trx_5_variant); BOOST_CHECK(!trx_6_variant); // need 2 blocks before 6 returned to user @@ -398,14 +398,14 @@ BOOST_AUTO_TEST_CASE(trx_retry_logic) { fc::mock_time_traits::set_now(pnow); auto bsp9 = make_block_state(9, {}); trx_retry.on_block_start(9); - trx_retry.on_accepted_block(bsp9); + trx_retry.on_accepted_block(bsp9->block_num); BOOST_CHECK(!trx_5_variant); BOOST_CHECK(!trx_6_variant); pnow += boost::posix_time::seconds(1); // new block, new time fc::mock_time_traits::set_now(pnow); auto bsp10 = make_block_state(10, {}); trx_retry.on_block_start(10); - trx_retry.on_accepted_block(bsp10); + trx_retry.on_accepted_block(bsp10->block_num); BOOST_CHECK(!trx_5_variant); BOOST_CHECK(trx_6_variant); // now signal lib for trx_6 @@ -413,13 +413,13 @@ BOOST_AUTO_TEST_CASE(trx_retry_logic) { fc::mock_time_traits::set_now(pnow); auto bsp11 = make_block_state(11, {}); trx_retry.on_block_start(11); - trx_retry.on_accepted_block(bsp11); + trx_retry.on_accepted_block(bsp11->block_num); BOOST_CHECK(!trx_5_variant); BOOST_CHECK(trx_6_variant); - trx_retry.on_irreversible_block(bsp7); + trx_retry.on_irreversible_block(bsp7->block); BOOST_CHECK(!trx_5_variant); BOOST_CHECK(trx_6_variant); - trx_retry.on_irreversible_block(bsp8); + trx_retry.on_irreversible_block(bsp8->block); BOOST_CHECK(trx_5_variant); BOOST_CHECK(trx_6_variant); BOOST_CHECK_EQUAL(0u, trx_retry.size()); @@ -456,7 +456,7 @@ BOOST_AUTO_TEST_CASE(trx_retry_logic) { // not in block 12 auto bsp12 = make_block_state(12, {}); trx_retry.on_block_start(12); - trx_retry.on_accepted_block(bsp12); + trx_retry.on_accepted_block(bsp12->block_num); BOOST_CHECK(!trx_7_variant); BOOST_CHECK(!trx_8_variant); BOOST_CHECK(!trx_9_expired); @@ -471,7 +471,7 @@ BOOST_AUTO_TEST_CASE(trx_retry_logic) { trx_retry.on_applied_transaction(trace_8, trx_8); trx_retry.on_applied_transaction(trace_9, trx_9); auto bsp13 = make_block_state(13, {trx_7, trx_8, trx_9}); - trx_retry.on_accepted_block(bsp13); + trx_retry.on_accepted_block(bsp13->block_num); BOOST_CHECK(!trx_7_variant); BOOST_CHECK(!trx_8_variant); BOOST_CHECK(!trx_9_expired); @@ -480,7 +480,7 @@ BOOST_AUTO_TEST_CASE(trx_retry_logic) { fc::mock_time_traits::set_now(pnow); auto bsp14 = make_block_state(14, {}); trx_retry.on_block_start(14); - trx_retry.on_accepted_block(bsp14); + trx_retry.on_accepted_block(bsp14->block_num); BOOST_CHECK(!trx_7_variant); BOOST_CHECK(!trx_8_variant); BOOST_CHECK(!trx_9_expired); @@ -488,7 +488,7 @@ BOOST_AUTO_TEST_CASE(trx_retry_logic) { fc::mock_time_traits::set_now(pnow); auto bsp15 = make_block_state(15, {}); trx_retry.on_block_start(15); - trx_retry.on_accepted_block(bsp15); + trx_retry.on_accepted_block(bsp15->block_num); BOOST_CHECK(!trx_7_variant); BOOST_CHECK(!trx_8_variant); BOOST_CHECK(!trx_9_expired); @@ -500,14 +500,14 @@ BOOST_AUTO_TEST_CASE(trx_retry_logic) { BOOST_CHECK_EQUAL(3u, trx_retry.size()); // now produce an empty 13 auto bsp13b = make_block_state(13, {}); // now 13 has no traces - trx_retry.on_accepted_block(bsp13b); + trx_retry.on_accepted_block(bsp13b->block_num); // produced another empty block pnow += boost::posix_time::seconds(1); // new block, new time fc::mock_time_traits::set_now(pnow); trx_retry.on_block_start(14); // now produce an empty 14 auto bsp14b = make_block_state(14, {}); // empty - trx_retry.on_accepted_block(bsp14b); + trx_retry.on_accepted_block(bsp14b->block_num); // produce block with 7,8 trx_retry.on_block_start(15); auto trace_7b = make_transaction_trace( trx_7, 15); @@ -515,13 +515,13 @@ BOOST_AUTO_TEST_CASE(trx_retry_logic) { trx_retry.on_applied_transaction(trace_7b, trx_7); trx_retry.on_applied_transaction(trace_8b, trx_8); auto bsp15b = make_block_state(15, {trx_7, trx_8}); - trx_retry.on_accepted_block(bsp15b); + trx_retry.on_accepted_block(bsp15b->block_num); // need 3 blocks before 8 returned to user pnow += boost::posix_time::seconds(1); // new block, new time fc::mock_time_traits::set_now(pnow); auto bsp16 = make_block_state(16, {}); trx_retry.on_block_start(16); - trx_retry.on_accepted_block(bsp16); + trx_retry.on_accepted_block(bsp16->block_num); BOOST_CHECK(!trx_7_variant); BOOST_CHECK(!trx_8_variant); BOOST_CHECK(!trx_9_expired); @@ -529,7 +529,7 @@ BOOST_AUTO_TEST_CASE(trx_retry_logic) { fc::mock_time_traits::set_now(pnow); auto bsp17 = make_block_state(17, {}); trx_retry.on_block_start(17); - trx_retry.on_accepted_block(bsp17); + trx_retry.on_accepted_block(bsp17->block_num); BOOST_CHECK(!trx_7_variant); BOOST_CHECK(!trx_8_variant); BOOST_CHECK(!trx_9_expired); @@ -537,20 +537,20 @@ BOOST_AUTO_TEST_CASE(trx_retry_logic) { fc::mock_time_traits::set_now(pnow); auto bsp18 = make_block_state(18, {}); trx_retry.on_block_start(18); - trx_retry.on_accepted_block(bsp18); + trx_retry.on_accepted_block(bsp18->block_num); BOOST_CHECK(!trx_7_variant); BOOST_CHECK(trx_8_variant); BOOST_CHECK(!trx_9_expired); - trx_retry.on_irreversible_block(bsp9); - trx_retry.on_irreversible_block(bsp10); - trx_retry.on_irreversible_block(bsp11); - trx_retry.on_irreversible_block(bsp12); - trx_retry.on_irreversible_block(bsp13b); - trx_retry.on_irreversible_block(bsp14b); + trx_retry.on_irreversible_block(bsp9->block); + trx_retry.on_irreversible_block(bsp10->block); + trx_retry.on_irreversible_block(bsp11->block); + trx_retry.on_irreversible_block(bsp12->block); + trx_retry.on_irreversible_block(bsp13b->block); + trx_retry.on_irreversible_block(bsp14b->block); BOOST_CHECK(!trx_7_variant); BOOST_CHECK(trx_8_variant); BOOST_CHECK(!trx_9_expired); - trx_retry.on_irreversible_block(bsp15b); + trx_retry.on_irreversible_block(bsp15b->block); BOOST_CHECK(trx_7_variant); BOOST_CHECK(trx_8_variant); BOOST_CHECK(!trx_9_expired); @@ -559,12 +559,12 @@ BOOST_AUTO_TEST_CASE(trx_retry_logic) { fc::mock_time_traits::set_now(pnow); auto bsp19 = make_block_state(19, {}); trx_retry.on_block_start(19); - trx_retry.on_accepted_block(bsp19); - trx_retry.on_irreversible_block(bsp15); - trx_retry.on_irreversible_block(bsp16); - trx_retry.on_irreversible_block(bsp17); - trx_retry.on_irreversible_block(bsp18); - trx_retry.on_irreversible_block(bsp19); + trx_retry.on_accepted_block(bsp19->block_num); + trx_retry.on_irreversible_block(bsp15->block); + trx_retry.on_irreversible_block(bsp16->block); + trx_retry.on_irreversible_block(bsp17->block); + trx_retry.on_irreversible_block(bsp18->block); + trx_retry.on_irreversible_block(bsp19->block); BOOST_CHECK(trx_7_variant); BOOST_CHECK(trx_8_variant); BOOST_CHECK(!trx_9_expired); @@ -572,12 +572,12 @@ BOOST_AUTO_TEST_CASE(trx_retry_logic) { fc::mock_time_traits::set_now(pnow); auto bsp20 = make_block_state(20, {}); trx_retry.on_block_start(20); - trx_retry.on_accepted_block(bsp20); + trx_retry.on_accepted_block(bsp20->block_num); // waits for LIB BOOST_CHECK(trx_7_variant); BOOST_CHECK(trx_8_variant); BOOST_CHECK(!trx_9_expired); - trx_retry.on_irreversible_block(bsp20); + trx_retry.on_irreversible_block(bsp20->block); BOOST_CHECK(trx_7_variant); BOOST_CHECK(trx_8_variant); BOOST_CHECK(trx_9_expired); @@ -607,14 +607,14 @@ BOOST_AUTO_TEST_CASE(trx_retry_logic) { trx_retry.on_applied_transaction(trace_10, trx_10); trx_retry.on_applied_transaction(trace_11, trx_11); auto bsp21 = make_block_state(21, {trx_10, trx_11}); - trx_retry.on_accepted_block(bsp21); + trx_retry.on_accepted_block(bsp21->block_num); BOOST_CHECK(trx_10_variant); BOOST_CHECK(!trx_11_variant); pnow += boost::posix_time::seconds(1); // new block, new time fc::mock_time_traits::set_now(pnow); auto bsp22 = make_block_state(22, {}); trx_retry.on_block_start(22); - trx_retry.on_accepted_block(bsp22); + trx_retry.on_accepted_block(bsp22->block_num); BOOST_CHECK(trx_10_variant); BOOST_CHECK(trx_11_variant); BOOST_CHECK_EQUAL(0u, trx_retry.size()); diff --git a/plugins/chain_plugin/trx_finality_status_processing.cpp b/plugins/chain_plugin/trx_finality_status_processing.cpp index 3bf7e691de..3ac42dbc3f 100644 --- a/plugins/chain_plugin/trx_finality_status_processing.cpp +++ b/plugins/chain_plugin/trx_finality_status_processing.cpp @@ -15,7 +15,7 @@ namespace eosio::chain_apis { void signal_applied_transaction( const chain::transaction_trace_ptr& trace, const chain::packed_transaction_ptr& ptrx ); - void signal_accepted_block( const chain::block_state_legacy_ptr& bsp ); + void signal_accepted_block( const chain::signed_block_ptr& block, const chain::block_id_type& id ); void handle_rollback(); @@ -47,10 +47,10 @@ namespace eosio::chain_apis { trx_finality_status_processing::~trx_finality_status_processing() = default; - void trx_finality_status_processing::signal_irreversible_block( const chain::block_state_legacy_ptr& bsp ) { + void trx_finality_status_processing::signal_irreversible_block( const chain::signed_block_ptr& block, const chain::block_id_type& id ) { try { - _my->_irr_block_id = bsp->id; - _my->_irr_block_timestamp = bsp->block->timestamp; + _my->_irr_block_id = id; + _my->_irr_block_timestamp = block->timestamp; } FC_LOG_AND_DROP(("Failed to signal irreversible block for finality status")); } @@ -67,9 +67,9 @@ namespace eosio::chain_apis { } FC_LOG_AND_DROP(("Failed to signal applied transaction for finality status")); } - void trx_finality_status_processing::signal_accepted_block( const chain::block_state_legacy_ptr& bsp ) { + void trx_finality_status_processing::signal_accepted_block( const chain::signed_block_ptr& block, const chain::block_id_type& id ) { try { - _my->signal_accepted_block(bsp); + _my->signal_accepted_block(block, id); } FC_LOG_AND_DROP(("Failed to signal accepted block for finality status")); } @@ -139,14 +139,14 @@ namespace eosio::chain_apis { } } - void trx_finality_status_processing_impl::signal_accepted_block( const chain::block_state_legacy_ptr& bsp ) { + void trx_finality_status_processing_impl::signal_accepted_block( const chain::signed_block_ptr& block, const chain::block_id_type& id ) { // if this block had any transactions, then we have processed everything we need to already - if (bsp->id == _head_block_id) { + if (id == _head_block_id) { return; } - _head_block_id = bsp->id; - _head_block_timestamp = bsp->block->timestamp; + _head_block_id = id; + _head_block_timestamp = block->timestamp; const auto head_block_num = chain::block_header::num_from_id(_head_block_id); if (head_block_num <= _last_proc_block_num) { diff --git a/plugins/chain_plugin/trx_retry_db.cpp b/plugins/chain_plugin/trx_retry_db.cpp index 4d0376cf99..1febd72513 100644 --- a/plugins/chain_plugin/trx_retry_db.cpp +++ b/plugins/chain_plugin/trx_retry_db.cpp @@ -161,15 +161,15 @@ struct trx_retry_db_impl { rollback_to( block_num ); } - void on_accepted_block(const chain::block_state_legacy_ptr& bsp ) { + void on_accepted_block( uint32_t block_num ) { // good time to perform processing - ack_ready_trxs_by_block_num( bsp->block_num ); + ack_ready_trxs_by_block_num( block_num ); retry_trxs(); } - void on_irreversible_block(const chain::block_state_legacy_ptr& bsp ) { - ack_ready_trxs_by_lib( bsp->block_num ); - clear_expired( bsp->block->timestamp ); + void on_irreversible_block( const chain::signed_block_ptr& block ) { + ack_ready_trxs_by_lib( block->block_num() ); + clear_expired( block->timestamp ); } private: @@ -321,13 +321,13 @@ void trx_retry_db::on_block_start( uint32_t block_num ) { } FC_LOG_AND_DROP(("trx retry block_start ERROR")); } -void trx_retry_db::on_accepted_block(const chain::block_state_legacy_ptr& block ) { +void trx_retry_db::on_accepted_block( uint32_t block_num ) { try { - _impl->on_accepted_block(block); + _impl->on_accepted_block(block_num); } FC_LOG_AND_DROP(("trx retry accepted_block ERROR")); } -void trx_retry_db::on_irreversible_block(const chain::block_state_legacy_ptr& block ) { +void trx_retry_db::on_irreversible_block(const chain::signed_block_ptr& block) { try { _impl->on_irreversible_block(block); } FC_LOG_AND_DROP(("trx retry irreversible_block ERROR")); diff --git a/plugins/net_plugin/net_plugin.cpp b/plugins/net_plugin/net_plugin.cpp index 991d095b7c..a59544d044 100644 --- a/plugins/net_plugin/net_plugin.cpp +++ b/plugins/net_plugin/net_plugin.cpp @@ -528,11 +528,11 @@ namespace eosio { uint32_t get_chain_lib_num() const; uint32_t get_chain_head_num() const; - void on_accepted_block_header( const block_state_legacy_ptr& bs ); - void on_accepted_block( const block_state_legacy_ptr& bs ); + void on_accepted_block_header( const signed_block_ptr& block, const block_id_type& id ); + void on_accepted_block(); void transaction_ack(const std::pair&); - void on_irreversible_block( const block_state_legacy_ptr& block ); + void on_irreversible_block( const block_id_type& id, uint32_t block_num ); void start_expire_timer(); void start_monitors(); @@ -3882,23 +3882,23 @@ namespace eosio { } // called from application thread - void net_plugin_impl::on_accepted_block_header(const block_state_legacy_ptr& bs) { + void net_plugin_impl::on_accepted_block_header(const signed_block_ptr& block, const block_id_type& id) { update_chain_info(); - dispatcher->strand.post([bs]() { - fc_dlog(logger, "signaled accepted_block_header, blk num = ${num}, id = ${id}", ("num", bs->block_num)("id", bs->id)); - my_impl->dispatcher->bcast_block(bs->block, bs->id); + dispatcher->strand.post([block, id]() { + fc_dlog(logger, "signaled accepted_block_header, blk num = ${num}, id = ${id}", ("num", block->block_num())("id", id)); + my_impl->dispatcher->bcast_block(block, id); }); } - void net_plugin_impl::on_accepted_block(const block_state_legacy_ptr& ) { + void net_plugin_impl::on_accepted_block() { on_pending_schedule(chain_plug->chain().pending_producers()); on_active_schedule(chain_plug->chain().active_producers()); } // called from application thread - void net_plugin_impl::on_irreversible_block( const block_state_legacy_ptr& block) { - fc_dlog( logger, "on_irreversible_block, blk num = ${num}, id = ${id}", ("num", block->block_num)("id", block->id) ); + void net_plugin_impl::on_irreversible_block( const block_id_type& id, uint32_t block_num) { + fc_dlog( logger, "on_irreversible_block, blk num = ${num}, id = ${id}", ("num", block_num)("id", id) ); update_chain_info(); } @@ -4284,15 +4284,17 @@ namespace eosio { { chain::controller& cc = chain_plug->chain(); - cc.accepted_block_header.connect( [my = shared_from_this()]( const block_state_legacy_ptr& s ) { - my->on_accepted_block_header( s ); + cc.accepted_block_header.connect( [my = shared_from_this()]( const block_signal_params& t ) { + const auto& [ block, id ] = t; + my->on_accepted_block_header( block, id ); } ); - cc.accepted_block.connect( [my = shared_from_this()]( const block_state_legacy_ptr& s ) { - my->on_accepted_block( s ); + cc.accepted_block.connect( [my = shared_from_this()]( const block_signal_params& t ) { + my->on_accepted_block(); } ); - cc.irreversible_block.connect( [my = shared_from_this()]( const block_state_legacy_ptr& s ) { - my->on_irreversible_block( s ); + cc.irreversible_block.connect( [my = shared_from_this()]( const block_signal_params& t ) { + const auto& [ block, id ] = t; + my->on_irreversible_block( id, block->block_num() ); } ); } diff --git a/plugins/producer_plugin/producer_plugin.cpp b/plugins/producer_plugin/producer_plugin.cpp index 8ad75c7945..9994ddaf27 100644 --- a/plugins/producer_plugin/producer_plugin.cpp +++ b/plugins/producer_plugin/producer_plugin.cpp @@ -620,19 +620,19 @@ class producer_plugin_impl : public std::enable_shared_from_thischain(); auto before = _unapplied_transactions.size(); - _unapplied_transactions.clear_applied(bsp); - chain.get_mutable_subjective_billing().on_block(_log, bsp, fc::time_point::now()); + _unapplied_transactions.clear_applied(block); + chain.get_mutable_subjective_billing().on_block(_log, block, fc::time_point::now()); if (before > 0) { fc_dlog(_log, "Removed applied transactions before: ${before}, after: ${after}", ("before", before)("after", _unapplied_transactions.size())); } } - void on_block_header(const block_state_legacy_ptr& bsp) { - if (_producers.contains(bsp->header.producer)) - _producer_watermarks.consider_new_watermark(bsp->header.producer, bsp->block_num, bsp->block->timestamp); + void on_block_header(chain::account_name producer, uint32_t block_num, chain::block_timestamp_type timestamp) { + if (_producers.contains(producer)) + _producer_watermarks.consider_new_watermark(producer, block_num, timestamp); } void on_irreversible_block(const signed_block_ptr& lib) { @@ -1329,10 +1329,18 @@ void producer_plugin_impl::plugin_startup() { EOS_ASSERT(_producers.empty() || chain_plug->accept_transactions(), plugin_config_exception, "node cannot have any producer-name configured because no block production is possible with no [api|p2p]-accepted-transactions"); - _accepted_block_connection.emplace(chain.accepted_block.connect([this](const auto& bsp) { on_block(bsp); })); - _accepted_block_header_connection.emplace(chain.accepted_block_header.connect([this](const auto& bsp) { on_block_header(bsp); })); - _irreversible_block_connection.emplace( - chain.irreversible_block.connect([this](const auto& bsp) { on_irreversible_block(bsp->block); })); + _accepted_block_connection.emplace(chain.accepted_block.connect([this](const block_signal_params& t) { + const auto& [ block, id ] = t; + on_block(block); + })); + _accepted_block_header_connection.emplace(chain.accepted_block_header.connect([this](const block_signal_params& t) { + const auto& [ block, id ] = t; + on_block_header(block->producer, block->block_num(), block->timestamp); + })); + _irreversible_block_connection.emplace(chain.irreversible_block.connect([this](const block_signal_params& t) { + const auto& [ block, id ] = t; + on_irreversible_block(block); + })); _block_start_connection.emplace(chain.block_start.connect([this, &chain](uint32_t bs) { try { diff --git a/plugins/producer_plugin/test/test_trx_full.cpp b/plugins/producer_plugin/test/test_trx_full.cpp index e664f081bd..51abbf3a3e 100644 --- a/plugins/producer_plugin/test/test_trx_full.cpp +++ b/plugins/producer_plugin/test/test_trx_full.cpp @@ -68,15 +68,15 @@ auto make_unique_trx( const chain_id_type& chain_id ) { } // verify all trxs are in blocks only once -bool verify_equal( const std::deque& trxs, const std::deque& all_blocks) { +bool verify_equal( const std::deque& trxs, const std::deque& all_blocks) { std::set trxs_ids; // trx can appear more than once if they were aborted std::set blk_trxs_ids; for( const auto& trx : trxs ) { trxs_ids.emplace( trx->id() ); } - for( const auto& bs : all_blocks ) { - for( const auto& trx_receipt : bs->block->transactions ) { + for( const auto& block : all_blocks ) { + for( const auto& trx_receipt : block->transactions ) { const auto& trx = std::get( trx_receipt.trx ).get_transaction(); blk_trxs_ids.emplace( trx.id() ); } @@ -126,13 +126,14 @@ BOOST_AUTO_TEST_CASE(producer) { auto[prod_plug, chain_plug] = plugin_fut.get(); auto chain_id = chain_plug->get_chain_id(); - std::deque all_blocks; + std::deque all_blocks; std::promise empty_blocks_promise; std::future empty_blocks_fut = empty_blocks_promise.get_future(); - auto ab = chain_plug->chain().accepted_block.connect( [&](const block_state_legacy_ptr& bsp) { + auto ab = chain_plug->chain().accepted_block.connect( [&](const chain::block_signal_params& t) { + const auto& [ block, id ] = t; static int num_empty = std::numeric_limits::max(); - all_blocks.push_back( bsp ); - if( bsp->block->transactions.empty() ) { + all_blocks.push_back( block ); + if( block->transactions.empty() ) { --num_empty; if( num_empty == 0 ) empty_blocks_promise.set_value(); } else { // we want a few empty blocks after we have some non-empty blocks diff --git a/plugins/state_history_plugin/include/eosio/state_history_plugin/session.hpp b/plugins/state_history_plugin/include/eosio/state_history_plugin/session.hpp index 51ac098af8..94da1e3e1d 100644 --- a/plugins/state_history_plugin/include/eosio/state_history_plugin/session.hpp +++ b/plugins/state_history_plugin/include/eosio/state_history_plugin/session.hpp @@ -1,5 +1,4 @@ #pragma once -#include #include #include #include @@ -26,7 +25,7 @@ struct send_queue_entry_base { struct session_base { virtual void send_update(bool changed) = 0; - virtual void send_update(const eosio::chain::block_state_legacy_ptr& block_state) = 0; + virtual void send_update(const chain::signed_block_ptr& block, const chain::block_id_type& id) = 0; virtual ~session_base() = default; std::optional current_request; @@ -35,15 +34,17 @@ struct session_base { class send_update_send_queue_entry : public send_queue_entry_base { std::shared_ptr session; - const chain::block_state_legacy_ptr block_state; + const chain::signed_block_ptr block; + const chain::block_id_type id; public: - send_update_send_queue_entry(std::shared_ptr s, chain::block_state_legacy_ptr block_state) + send_update_send_queue_entry(std::shared_ptr s, chain::signed_block_ptr block, const chain::block_id_type& id) : session(std::move(s)) - , block_state(std::move(block_state)){} + , block(std::move(block)) + , id(id){} void send_entry() override { - if( block_state ) { - session->send_update(block_state); + if( block) { + session->send_update(block, id); } else { session->send_update(false); } @@ -118,14 +119,14 @@ class session_manager { void send_updates() { for( auto& s : session_set ) { if (s->need_to_send_update ) { - add_send_queue(s, std::make_unique(s, nullptr)); + add_send_queue(s, std::make_unique(s, nullptr, chain::block_id_type{})); } } } - void send_update(const chain::block_state_legacy_ptr& block_state) { + void send_update(const chain::signed_block_ptr& block, const chain::block_id_type& id) { for( auto& s : session_set ) { - add_send_queue(s, std::make_unique(s, block_state)); + add_send_queue(s, std::make_unique(s, block, id)); } } @@ -481,7 +482,7 @@ struct session : session_base, std::enable_shared_from_thismax_messages_in_flight) { session_mgr.pop_entry(false); @@ -502,7 +503,7 @@ struct session : session_base, std::enable_shared_from_this block_id = - (block_state && block_state->block_num == to_send_block_num) ? block_state->id : plugin.get_block_id(to_send_block_num); + (block && block->block_num() == to_send_block_num) ? id : plugin.get_block_id(to_send_block_num); if (block_id && position_it && (*position_it)->block_num == to_send_block_num) { // This branch happens when the head block of nodeos is behind the head block of connecting client. @@ -526,8 +527,10 @@ struct session : session_base, std::enable_shared_from_thisfetch_block) - plugin.get_block(to_send_block_num, block_state, result.block); + if (current_request->fetch_block) { + uint32_t block_num = block ? block->block_num() : 0; // block can be nullptr in testing + plugin.get_block(to_send_block_num, block_num, block, result.block); + } if (current_request->fetch_traces && plugin.get_trace_log()) result.traces.emplace(); if (current_request->fetch_deltas && plugin.get_chain_state_log()) @@ -554,23 +557,24 @@ struct session : session_base, std::enable_shared_from_this>(this->shared_from_this(), std::move(result))->send_entry(); } - void send_update(const chain::block_state_legacy_ptr& block_state) override { + void send_update(const chain::signed_block_ptr& block, const chain::block_id_type& id) override { if (!current_request || !current_request->max_messages_in_flight) { session_mgr.pop_entry(false); return; } + auto block_num = block->block_num(); state_history::get_blocks_result_v0 result; - result.head = {block_state->block_num, block_state->id}; - to_send_block_num = std::min(block_state->block_num, to_send_block_num); - send_update(std::move(result), block_state); + result.head = {block_num, id}; + to_send_block_num = std::min(block_num, to_send_block_num); + send_update(std::move(result), block, id); } void send_update(bool changed) override { if (changed || need_to_send_update) { state_history::get_blocks_result_v0 result; result.head = plugin.get_block_head(); - send_update(std::move(result), {}); + send_update(std::move(result), nullptr, chain::block_id_type{}); } else { session_mgr.pop_entry(false); } diff --git a/plugins/state_history_plugin/state_history_plugin.cpp b/plugins/state_history_plugin/state_history_plugin.cpp index 83fcec261f..c40a695e2f 100644 --- a/plugins/state_history_plugin/state_history_plugin.cpp +++ b/plugins/state_history_plugin/state_history_plugin.cpp @@ -88,11 +88,11 @@ struct state_history_plugin_impl : std::enable_shared_from_thisblock_num) { - p = block_state->block; + if (block_num == block_state_block_num) { + p = block; } else { p = chain_plug->chain().fetch_block_by_number(block_num); } @@ -107,8 +107,8 @@ struct state_history_plugin_impl : std::enable_shared_from_this& result) const { - auto p = get_block(block_num, block_state); + void get_block(uint32_t block_num, uint32_t block_state_block_num, const signed_block_ptr& block, std::optional& result) const { + auto p = get_block(block_num, block_state_block_num, block); if (p) result = fc::raw::pack(*p); } @@ -201,12 +201,12 @@ struct state_history_plugin_impl : std::enable_shared_from_this(*block), block->block_num()); } catch (const fc::exception& e) { fc_elog(_log, "fc::exception: ${details}", ("details", e.to_detail_string())); // Both app().quit() and exception throwing are required. Without app().quit(), @@ -224,8 +224,8 @@ struct state_history_plugin_impl : std::enable_shared_from_thisshared_from_this(), block_state]() { - self->get_session_manager().send_update(block_state); + boost::asio::post(get_ship_executor(), [self = this->shared_from_this(), block, id]() { + self->get_session_manager().send_update(block, id); }); } @@ -243,29 +243,29 @@ struct state_history_plugin_impl : std::enable_shared_from_thisid, + .block_id = id, .payload_size = 0}; - trace_log->pack_and_write_entry(header, block_state->block->previous, [this, &block_state](auto&& buf) { - trace_converter.pack(buf, trace_debug_mode, block_state); + trace_log->pack_and_write_entry(header, block->previous, [this, &block](auto&& buf) { + trace_converter.pack(buf, trace_debug_mode, block); }); } // called from main thread - void store_chain_state(const block_state_legacy_ptr& block_state) { + void store_chain_state(const block_id_type& id, const signed_block_header& block_header, uint32_t block_num) { if (!chain_state_log) return; bool fresh = chain_state_log->empty(); if (fresh) - fc_ilog(_log, "Placing initial state in block ${n}", ("n", block_state->block_num)); + fc_ilog(_log, "Placing initial state in block ${n}", ("n", block_num)); state_history_log_header header{ - .magic = ship_magic(ship_current_version, 0), .block_id = block_state->id, .payload_size = 0}; - chain_state_log->pack_and_write_entry(header, block_state->header.previous, [this, fresh](auto&& buf) { + .magic = ship_magic(ship_current_version, 0), .block_id = id, .payload_size = 0}; + chain_state_log->pack_and_write_entry(header, block_header.previous, [this, fresh](auto&& buf) { pack_deltas(buf, chain_plug->chain().db(), fresh); }); } // store_chain_state @@ -329,7 +329,10 @@ void state_history_plugin_impl::plugin_initialize(const variables_map& options) on_applied_transaction(std::get<0>(t), std::get<1>(t)); })); accepted_block_connection.emplace( - chain.accepted_block.connect([&](const block_state_legacy_ptr& p) { on_accepted_block(p); })); + chain.accepted_block.connect([&](const block_signal_params& t) { + const auto& [ block, id ] = t; + on_accepted_block(block, id); + })); block_start_connection.emplace( chain.block_start.connect([&](uint32_t block_num) { on_block_start(block_num); })); @@ -406,7 +409,7 @@ void state_history_plugin_impl::plugin_startup() { auto bsp = chain.head_block_state(); if( bsp && chain_state_log && chain_state_log->empty() ) { fc_ilog( _log, "Storing initial state on startup, this can take a considerable amount of time" ); - store_chain_state( bsp ); + store_chain_state( bsp->id, bsp->header, bsp->block_num ); fc_ilog( _log, "Done storing initial state on startup" ); } first_available_block = chain.earliest_available_block_num(); diff --git a/plugins/state_history_plugin/tests/session_test.cpp b/plugins/state_history_plugin/tests/session_test.cpp index 6ca9cfd3c5..bcfb2a219d 100644 --- a/plugins/state_history_plugin/tests/session_test.cpp +++ b/plugins/state_history_plugin/tests/session_test.cpp @@ -123,7 +123,7 @@ struct mock_state_history_plugin { fc::logger& get_logger() { return logger; } - void get_block(uint32_t block_num, const eosio::chain::block_state_legacy_ptr& block_state, + void get_block(uint32_t block_num, uint32_t block_state_block_num, const eosio::chain::signed_block_ptr& block, std::optional& result) const { result.emplace().resize(16); } diff --git a/plugins/test_control_plugin/test_control_plugin.cpp b/plugins/test_control_plugin/test_control_plugin.cpp index 4ff52bc1fd..2bf43bdb55 100644 --- a/plugins/test_control_plugin/test_control_plugin.cpp +++ b/plugins/test_control_plugin/test_control_plugin.cpp @@ -15,9 +15,9 @@ class test_control_plugin_impl { void kill_on_head(account_name prod, uint32_t where_in_seq); private: - void accepted_block(const chain::block_state_legacy_ptr& bsp); - void applied_irreversible_block(const chain::block_state_legacy_ptr& bsp); - void process_next_block_state_legacy(const chain::block_state_legacy_ptr& bsp); + void accepted_block(const chain::block_id_type& id); + void applied_irreversible_block(const chain::block_id_type& id); + void process_next_block_state(const chain::block_id_type& id); std::optional _accepted_block_connection; std::optional _irreversible_block_connection; @@ -32,12 +32,14 @@ class test_control_plugin_impl { void test_control_plugin_impl::connect() { _irreversible_block_connection.emplace( - _chain.irreversible_block.connect( [&]( const chain::block_state_legacy_ptr& bs ) { - applied_irreversible_block( bs ); + _chain.irreversible_block.connect( [&]( const chain::block_signal_params& t ) { + const auto& [ block, id ] = t; + applied_irreversible_block( id ); } )); _accepted_block_connection = - _chain.accepted_block.connect( [&]( const chain::block_state_legacy_ptr& bs ) { - accepted_block( bs ); + _chain.accepted_block.connect( [&]( const chain::block_signal_params& t ) { + const auto& [ block, id ] = t; + accepted_block( id ); } ); } @@ -46,19 +48,21 @@ void test_control_plugin_impl::disconnect() { _irreversible_block_connection.reset(); } -void test_control_plugin_impl::applied_irreversible_block(const chain::block_state_legacy_ptr& bsp) { +void test_control_plugin_impl::applied_irreversible_block(const chain::block_id_type& id) { if (_track_lib) - process_next_block_state_legacy(bsp); + process_next_block_state(id); } -void test_control_plugin_impl::accepted_block(const chain::block_state_legacy_ptr& bsp) { +void test_control_plugin_impl::accepted_block(const chain::block_id_type& id) { if (_track_head) - process_next_block_state_legacy(bsp); + process_next_block_state(id); } -void test_control_plugin_impl::process_next_block_state_legacy(const chain::block_state_legacy_ptr& bsp) { +void test_control_plugin_impl::process_next_block_state(const chain::block_id_type& id) { // Tests expect the shutdown only after signaling a producer shutdown and seeing a full production cycle const auto block_time = _chain.head_block_time() + fc::microseconds(chain::config::block_interval_us); + // have to fetch bsp due to get_scheduled_producer call + const auto& bsp = _chain.fetch_block_state_by_id(id); const auto& producer_authority = bsp->get_scheduled_producer(block_time); const auto producer_name = producer_authority.producer_name; const auto slot = bsp->block->timestamp.slot % chain::config::producer_repetitions; diff --git a/plugins/trace_api_plugin/include/eosio/trace_api/chain_extraction.hpp b/plugins/trace_api_plugin/include/eosio/trace_api/chain_extraction.hpp index 9a588161e9..05860bb1ef 100644 --- a/plugins/trace_api_plugin/include/eosio/trace_api/chain_extraction.hpp +++ b/plugins/trace_api_plugin/include/eosio/trace_api/chain_extraction.hpp @@ -31,13 +31,13 @@ class chain_extraction_impl_type { } /// connect to chain controller accepted_block signal - void signal_accepted_block( const chain::block_state_legacy_ptr& bsp ) { - on_accepted_block( bsp ); + void signal_accepted_block( const chain::signed_block_ptr& block, const chain::block_id_type& id ) { + on_accepted_block( block, id ); } /// connect to chain controller irreversible_block signal - void signal_irreversible_block( const chain::block_state_legacy_ptr& bsp ) { - on_irreversible_block( bsp ); + void signal_irreversible_block( uint32_t block_num ) { + on_irreversible_block( block_num ); } /// connect to chain controller block_start signal @@ -63,12 +63,12 @@ class chain_extraction_impl_type { } } - void on_accepted_block(const chain::block_state_legacy_ptr& block_state) { - store_block_trace( block_state ); + void on_accepted_block(const chain::signed_block_ptr& block, const chain::block_id_type& id ) { + store_block_trace( block, id ); } - void on_irreversible_block( const chain::block_state_legacy_ptr& block_state ) { - store_lib( block_state ); + void on_irreversible_block( uint32_t block_num ) { + store_lib( block_num ); } void on_block_start( uint32_t block_num ) { @@ -80,18 +80,18 @@ class chain_extraction_impl_type { onblock_trace.reset(); } - void store_block_trace( const chain::block_state_legacy_ptr& block_state ) { + void store_block_trace( const chain::signed_block_ptr& block, const chain::block_id_type& id ) { try { using transaction_trace_t = transaction_trace_v3; - auto bt = create_block_trace( block_state ); + auto bt = create_block_trace( block, id ); std::vector traces; - traces.reserve( block_state->block->transactions.size() + 1 ); + traces.reserve( block->transactions.size() + 1 ); block_trxs_entry tt; - tt.ids.reserve(block_state->block->transactions.size() + 1); + tt.ids.reserve(block->transactions.size() + 1); if( onblock_trace ) traces.emplace_back( to_transaction_trace( *onblock_trace )); - for( const auto& r : block_state->block->transactions ) { + for( const auto& r : block->transactions ) { transaction_id_type id; if( std::holds_alternative(r.trx)) { id = std::get(r.trx); @@ -117,9 +117,9 @@ class chain_extraction_impl_type { } } - void store_lib( const chain::block_state_legacy_ptr& bsp ) { + void store_lib( uint32_t block_num ) { try { - store.append_lib( bsp->block_num ); + store.append_lib( block_num ); } catch( ... ) { except_handler( MAKE_EXCEPTION_WITH_CONTEXT( std::current_exception() ) ); } diff --git a/plugins/trace_api_plugin/include/eosio/trace_api/extract_util.hpp b/plugins/trace_api_plugin/include/eosio/trace_api/extract_util.hpp index d0f143bc1f..ce240a9b5e 100644 --- a/plugins/trace_api_plugin/include/eosio/trace_api/extract_util.hpp +++ b/plugins/trace_api_plugin/include/eosio/trace_api/extract_util.hpp @@ -1,7 +1,6 @@ #pragma once #include -#include namespace eosio { namespace trace_api { @@ -63,16 +62,16 @@ inline TransactionTrace to_transaction_trace( const cache_trace& t ) { return r; } -inline block_trace_v2 create_block_trace( const chain::block_state_legacy_ptr& bsp ) { +inline block_trace_v2 create_block_trace( const chain::signed_block_ptr& block, const chain::block_id_type& id ) { block_trace_v2 r; - r.id = bsp->id; - r.number = bsp->block_num; - r.previous_id = bsp->block->previous; - r.timestamp = bsp->block->timestamp; - r.producer = bsp->block->producer; - r.schedule_version = bsp->block->schedule_version; - r.transaction_mroot = bsp->block->transaction_mroot; - r.action_mroot = bsp->block->action_mroot; + r.id = id; + r.number = block->block_num(); + r.previous_id = block->previous; + r.timestamp = block->timestamp; + r.producer = block->producer; + r.schedule_version = block->schedule_version; + r.transaction_mroot = block->transaction_mroot; + r.action_mroot = block->action_mroot; return r; } diff --git a/plugins/trace_api_plugin/test/test_extraction.cpp b/plugins/trace_api_plugin/test/test_extraction.cpp index 22450e1997..e053ce6c52 100644 --- a/plugins/trace_api_plugin/test/test_extraction.cpp +++ b/plugins/trace_api_plugin/test/test_extraction.cpp @@ -137,7 +137,7 @@ struct extraction_test_fixture { } void signal_accepted_block( const chain::block_state_legacy_ptr& bsp ) { - extraction_impl.signal_accepted_block(bsp); + extraction_impl.signal_accepted_block(bsp->block, bsp->id); } // fixture data and methods diff --git a/plugins/trace_api_plugin/trace_api_plugin.cpp b/plugins/trace_api_plugin/trace_api_plugin.cpp index a05da93e62..8aa7ea9556 100644 --- a/plugins/trace_api_plugin/trace_api_plugin.cpp +++ b/plugins/trace_api_plugin/trace_api_plugin.cpp @@ -377,16 +377,18 @@ struct trace_api_plugin_impl { })); accepted_block_connection.emplace( - chain.accepted_block.connect([this](const chain::block_state_legacy_ptr& p) { + chain.accepted_block.connect([this](const chain::block_signal_params& t) { emit_killer([&](){ - extraction->signal_accepted_block(p); + const auto& [ block, id ] = t; + extraction->signal_accepted_block(block, id); }); })); irreversible_block_connection.emplace( - chain.irreversible_block.connect([this](const chain::block_state_legacy_ptr& p) { + chain.irreversible_block.connect([this](const chain::block_signal_params& t) { + const auto& [ block, id ] = t; emit_killer([&](){ - extraction->signal_irreversible_block(p); + extraction->signal_irreversible_block(block->block_num()); }); })); diff --git a/unittests/api_tests.cpp b/unittests/api_tests.cpp index 294c3eb062..598f230bdd 100644 --- a/unittests/api_tests.cpp +++ b/unittests/api_tests.cpp @@ -1470,8 +1470,10 @@ void transaction_tests(T& chain) { auto& t = std::get<0>(x); if (t && t->receipt && t->receipt->status != transaction_receipt::executed) { trace = t; } } ); - block_state_legacy_ptr bsp; - auto c2 = chain.control->accepted_block.connect([&](const block_state_legacy_ptr& b) { bsp = b; }); + signed_block_ptr block; + auto c2 = chain.control->accepted_block.connect([&](block_signal_params t) { + const auto& [ b, id ] = t; + block = b; }); // test error handling on deferred transaction failure auto test_trace = CALL_TEST_FUNCTION(chain, "test_transaction", "send_transaction_trigger_error_handler", {}); @@ -1480,7 +1482,7 @@ void transaction_tests(T& chain) { BOOST_CHECK_EQUAL(trace->receipt->status, transaction_receipt::soft_fail); std::set block_ids; - for( const auto& receipt : bsp->block->transactions ) { + for( const auto& receipt : block->transactions ) { transaction_id_type id; if( std::holds_alternative(receipt.trx) ) { const auto& pt = std::get(receipt.trx); diff --git a/unittests/block_tests.cpp b/unittests/block_tests.cpp index 92e48c095f..d75832ac09 100644 --- a/unittests/block_tests.cpp +++ b/unittests/block_tests.cpp @@ -217,11 +217,13 @@ BOOST_AUTO_TEST_CASE(broadcasted_block_test) signed_block_ptr bcasted_blk_by_prod_node; signed_block_ptr bcasted_blk_by_recv_node; - producer_node.control->accepted_block.connect( [&](const block_state_legacy_ptr& bs) { - bcasted_blk_by_prod_node = bs->block; + producer_node.control->accepted_block.connect( [&](block_signal_params t) { + const auto& [ block, id ] = t; + bcasted_blk_by_prod_node = block; }); - receiving_node.control->accepted_block.connect( [&](const block_state_legacy_ptr& bs) { - bcasted_blk_by_recv_node = bs->block; + receiving_node.control->accepted_block.connect( [&](block_signal_params t) { + const auto& [ block, id ] = t; + bcasted_blk_by_recv_node = block; }); auto b = producer_node.produce_block(); diff --git a/unittests/chain_tests.cpp b/unittests/chain_tests.cpp index 5045fb7dc7..05fb688e3a 100644 --- a/unittests/chain_tests.cpp +++ b/unittests/chain_tests.cpp @@ -149,41 +149,53 @@ BOOST_AUTO_TEST_CASE( signal_validated_blocks ) try { tester chain; tester validator; - block_state_legacy_ptr accepted_bsp; - auto c = chain.control->accepted_block.connect([&](const block_state_legacy_ptr& b) { - BOOST_CHECK(b); - BOOST_CHECK(chain.control->fetch_block_state_by_id(b->id) == b); - BOOST_CHECK(chain.control->fetch_block_state_by_number(b->block_num) == b); // verify it can be found (has to be validated) - BOOST_CHECK(chain.control->fetch_block_by_id(b->id) == b->block); - BOOST_CHECK(chain.control->fetch_block_by_number(b->block_num) == b->block); - BOOST_REQUIRE(chain.control->fetch_block_header_by_number(b->block_num)); - BOOST_CHECK(chain.control->fetch_block_header_by_number(b->block_num)->calculate_id() == b->id); - BOOST_REQUIRE(chain.control->fetch_block_header_by_id(b->id)); - BOOST_CHECK(chain.control->fetch_block_header_by_id(b->id)->calculate_id() == b->id); - accepted_bsp = b; + signed_block_ptr accepted_block; + block_id_type accepted_id; + auto c = chain.control->accepted_block.connect([&](block_signal_params t) { + const auto& [ block, id ] = t; + auto block_num = block->block_num(); + BOOST_CHECK(block); + const auto& bsp_by_id = chain.control->fetch_block_state_by_id(id); + BOOST_CHECK(bsp_by_id->block_num == block_num); + const auto& bsp_by_number = chain.control->fetch_block_state_by_number(block_num); // verify it can be found (has to be validated) + BOOST_CHECK(bsp_by_number->id == id); + BOOST_CHECK(chain.control->fetch_block_by_id(id) == block); + BOOST_CHECK(chain.control->fetch_block_by_number(block_num) == block); + BOOST_REQUIRE(chain.control->fetch_block_header_by_number(block_num)); + BOOST_CHECK(chain.control->fetch_block_header_by_number(block_num)->calculate_id() == id); + BOOST_REQUIRE(chain.control->fetch_block_header_by_id(id)); + BOOST_CHECK(chain.control->fetch_block_header_by_id(id)->calculate_id() == id); + accepted_block = block; + accepted_id = id; }); - block_state_legacy_ptr validated_bsp; - auto c2 = validator.control->accepted_block.connect([&](const block_state_legacy_ptr& b) { - BOOST_CHECK(b); - BOOST_CHECK(validator.control->fetch_block_state_by_id(b->id) == b); - BOOST_CHECK(validator.control->fetch_block_state_by_number(b->block_num) == b); // verify it can be found (has to be validated) - BOOST_CHECK(validator.control->fetch_block_by_id(b->id) == b->block); - BOOST_CHECK(validator.control->fetch_block_by_number(b->block_num) == b->block); - BOOST_REQUIRE(validator.control->fetch_block_header_by_number(b->block_num)); - BOOST_CHECK(validator.control->fetch_block_header_by_number(b->block_num)->calculate_id() == b->id); - BOOST_REQUIRE(validator.control->fetch_block_header_by_id(b->id)); - BOOST_CHECK(validator.control->fetch_block_header_by_id(b->id)->calculate_id() == b->id); - validated_bsp = b; + signed_block_ptr validated_block; + block_id_type validated_id; + auto c2 = validator.control->accepted_block.connect([&](block_signal_params t) { + const auto& [ block, id ] = t; + auto block_num = block->block_num(); + BOOST_CHECK(block); + const auto& bsp_by_id = validator.control->fetch_block_state_by_id(id); + BOOST_CHECK(bsp_by_id->block_num == block_num); + const auto& bsp_by_number = validator.control->fetch_block_state_by_number(block_num); // verify it can be found (has to be validated) + BOOST_CHECK(bsp_by_number->id == id); + BOOST_CHECK(validator.control->fetch_block_by_id(id) == block); + BOOST_CHECK(validator.control->fetch_block_by_number(block_num) == block); + BOOST_REQUIRE(validator.control->fetch_block_header_by_number(block_num)); + BOOST_CHECK(validator.control->fetch_block_header_by_number(block_num)->calculate_id() == id); + BOOST_REQUIRE(validator.control->fetch_block_header_by_id(id)); + BOOST_CHECK(validator.control->fetch_block_header_by_id(id)->calculate_id() == id); + validated_block = block; + validated_id = id; }); chain.produce_blocks(1); - validator.push_block(accepted_bsp->block); + validator.push_block(accepted_block); chain.create_account("hello"_n); auto produced_block = chain.produce_block(); - validator.push_block(accepted_bsp->block); - BOOST_CHECK(produced_block->calculate_id() == accepted_bsp->id); - BOOST_CHECK(accepted_bsp->id == validated_bsp->id); + validator.push_block(accepted_block); + BOOST_CHECK(produced_block->calculate_id() == accepted_id); + BOOST_CHECK(accepted_id == validated_id); } FC_LOG_AND_RETHROW() diff --git a/unittests/forked_tests.cpp b/unittests/forked_tests.cpp index c5b4e38a80..57ffa266ec 100644 --- a/unittests/forked_tests.cpp +++ b/unittests/forked_tests.cpp @@ -351,10 +351,15 @@ BOOST_AUTO_TEST_CASE( validator_accepts_valid_blocks ) try { auto id = n1.control->head_block_id(); - block_state_legacy_ptr first_block; - - auto c = n2.control->accepted_block.connect( [&]( const block_state_legacy_ptr& bsp) { - first_block = bsp; + signed_block_ptr first_block; + block_id_type first_id; + signed_block_header first_header; + + auto c = n2.control->accepted_block.connect( [&]( block_signal_params t ) { + const auto& [ block, id ] = t; + first_block = block; + first_id = id; + first_header = static_cast(*block); } ); push_blocks( n1, n2 ); @@ -362,13 +367,14 @@ BOOST_AUTO_TEST_CASE( validator_accepts_valid_blocks ) try { BOOST_CHECK_EQUAL( n2.control->head_block_id(), id ); BOOST_REQUIRE( first_block ); - first_block->verify_signee(); - BOOST_CHECK_EQUAL( first_block->header.calculate_id(), first_block->block->calculate_id() ); - BOOST_CHECK( first_block->header.producer_signature == first_block->block->producer_signature ); + const auto& first_bsp = n2.control->fetch_block_state_by_id(first_id); + first_bsp->verify_signee(); + BOOST_CHECK_EQUAL( first_header.calculate_id(), first_block->calculate_id() ); + BOOST_CHECK( first_header.producer_signature == first_block->producer_signature ); c.disconnect(); - n3.push_block( first_block->block ); + n3.push_block( first_block ); BOOST_CHECK_EQUAL( n3.control->head_block_id(), id ); @@ -697,8 +703,9 @@ BOOST_AUTO_TEST_CASE( push_block_returns_forked_transactions ) try { // test forked blocks signal accepted_block in order, required by trace_api_plugin std::vector accepted_blocks; - auto conn = c.control->accepted_block.connect( [&]( const block_state_legacy_ptr& bsp) { - accepted_blocks.emplace_back( bsp->block ); + auto conn = c.control->accepted_block.connect( [&]( block_signal_params t ) { + const auto& [ block, id ] = t; + accepted_blocks.emplace_back( block ); } ); // dan on chain 1 now gets all of the blocks from chain 2 which should cause fork switch diff --git a/unittests/state_history_tests.cpp b/unittests/state_history_tests.cpp index 1f46576e36..2114bf7647 100644 --- a/unittests/state_history_tests.cpp +++ b/unittests/state_history_tests.cpp @@ -631,16 +631,17 @@ struct state_history_tester : state_history_tester_logs, tester { trace_converter.add_transaction(std::get<0>(t), std::get<1>(t)); }); - control.accepted_block.connect([&](const block_state_legacy_ptr& block_state) { + control.accepted_block.connect([&](block_signal_params t) { + const auto& [ block, id ] = t; eosio::state_history_log_header header{.magic = eosio::ship_magic(eosio::ship_current_version, 0), - .block_id = block_state->id, + .block_id = id, .payload_size = 0}; - traces_log.pack_and_write_entry(header, block_state->block->previous, [this, &block_state](auto&& buf) { - trace_converter.pack(buf, false, block_state); + traces_log.pack_and_write_entry(header, block->previous, [this, &block](auto&& buf) { + trace_converter.pack(buf, false, block); }); - chain_state_log.pack_and_write_entry(header, block_state->header.previous, [&control](auto&& buf) { + chain_state_log.pack_and_write_entry(header, block->previous, [&control](auto&& buf) { eosio::state_history::pack_deltas(buf, control.db(), true); }); }); diff --git a/unittests/unapplied_transaction_queue_tests.cpp b/unittests/unapplied_transaction_queue_tests.cpp index 13e279d71b..5d91202698 100644 --- a/unittests/unapplied_transaction_queue_tests.cpp +++ b/unittests/unapplied_transaction_queue_tests.cpp @@ -124,7 +124,8 @@ BOOST_AUTO_TEST_CASE( unapplied_transaction_queue_test ) try { // clear applied q.add_aborted( { trx1, trx2, trx3 } ); - q.clear_applied( create_test_block_state( { trx1, trx3, trx4 } ) ); + auto bs0 = create_test_block_state( { trx1, trx3, trx4 } ); + q.clear_applied( bs0->block ); BOOST_CHECK( q.size() == 1u ); BOOST_REQUIRE( next( q ) == trx2 ); BOOST_CHECK( q.size() == 0u );